【JAVA进阶篇教学】第十篇:Java中线程安全、锁讲解

简介: 【JAVA进阶篇教学】第十篇:Java中线程安全、锁讲解

博主打算从0-1讲解下java进阶篇教学,今天教学第十篇:Java中线程安全、锁讲解。


当涉及到多线程编程时,保证线程安全是至关重要的。线程安全意味着在多个线程访问共享资源时,不会发生数据错乱或不一致的情况。为了实现线程安全,通常需要使用锁机制来控制对共享资源的访问。在Java中,常见的线程安全技术包括使用synchronized关键字,ReentrantLock,读写锁,以及使用volatile关键字。


此文章会长期更新补充完整~~,敬请期待!

一、synchronized

Synchronized是 Java 中的一个关键字,用于实现线程同步。它可以修饰方法或代码块,确保在同一时间只有一个线程可以执行被修饰的代码。

Synchronized是一种互斥锁,也称为悲观锁。它的原理是在执行被修饰的代码之前,线程会尝试获取锁。如果锁已经被其他线程持有,那么当前线程将被阻塞,直到锁被释放。


注意:在实际应用中,需要根据具体情况合理使用Synchronized锁,避免过度使用导致性能下降。


1.线程不安全实例

public class UnsafeCounter {
    private int count = 0;
 
    public void increment() {
        count++;
    }
 
    public int getCount() {
        return count;
    }
}

假设有两个线程同时调用 increment() 方法增加计数:

public class UnsafeCounterExample {
    public static void main(String[] args) {
        UnsafeCounter counter = new UnsafeCounter();
 
        // 创建两个线程并发增加计数
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        thread1.start();
        thread2.start();
 
        // 等待两个线程执行完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 输出最终计数值
        System.out.println("Count: " + counter.getCount()); // 预期结果: 可能小于 2000
    }
}

在这个示例中,由于 increment() 方法没有同步控制,两个线程同时对 count 进行增加操作,可能导致计数不准确。理论上来说,代码应该执行的结果是:2000,但是因为线程不安全,就会导致数据不正确!

第一次运行:

第二次运行:

看到没,结果都会不一样,这要是正式环境中金额的话,那就不得了啦。

2.线程安全实例

使用synchronized修复线程安全问题

public class SafeCounter {
    private int count = 0;
 
    public synchronized void increment() {
        count++;
    }
 
    public synchronized int getCount() {
        return count;
    }
}

在 SafeCounter 类中,我们使用 synchronized 关键字修饰了 increment() 和 getCount() 方法,确保同一时刻只有一个线程可以执行这些方法。

public class SafeCounterExample {
    public static void main(String[] args) {
        SafeCounter counter = new SafeCounter();
 
        // 创建两个线程并发增加计数
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        thread1.start();
        thread2.start();
 
        // 等待两个线程执行完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 输出最终计数值
        System.out.println("Count: " + counter.getCount()); // 预期结果: 2000
    }
}

在这个示例中,由于使用了 synchronized 关键字修饰方法,保证了线程安全,最终输出的计数值是准确的。

第一次运行:

第二次运行:

可以很清楚的看到,正确的数据是:2000。上面的是synchronized直接修饰了方法,那么接下来使用synchronized来修饰代码块来实现!

3.synchronized修饰代码块

public class SafeCounter {
    private int count = 0;
 
    public void increment() {
        synchronized (this) {
            count++;
        }
    }
 
    public int getCount() {
        synchronized (this) {
            return count;
        }
    }
}

在这个示例中,我们使用了 synchronized 关键字来修饰 increment() 和 getCount() 方法中的代码块,同时传入了 this 作为锁对象。这样就确保了在同一时刻只有一个线程可以访问被 synchronized 修饰的代码块,从而实现了线程安全。

public class SafeCounterExample {
    public static void main(String[] args) {
        SafeCounter counter = new SafeCounter();
 
        // 创建两个线程并发增加计数
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });
 
        thread1.start();
        thread2.start();
 
        // 等待两个线程执行完成
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        // 输出最终计数值
        System.out.println("Count: " + counter.getCount()); // 预期结果: 2000
    }
}

第一次运行:

第二次运行:

需要注意:

synchronized (this)适用场景:

  1. 当需要在多个线程间同步访问对象实例的非静态方法或成员变量时,可以使用 synchronized (this) 来锁定当前对象实例,确保同一时刻只有一个线程访问对象的方法或成员变量。
  2. 示例:在多线程环境下,如果有多个线程同时操作同一个对象实例的方法或成员变量时,可以使用 synchronized (this) 来确保线程安全。


synchronized (SafeCounter.class)适用场景:


  1. 当需要在多个线程间同步访问类的静态方法或静态变量时,可以使用 synchronized (SafeCounter.class) 来锁定类对象,确保同一时刻只有一个线程访问类的静态方法或静态变量。
  2. 示例:在多线程环境下,如果有多个线程同时调用同一个类的静态方法或静态变量时,可以使用 synchronized (SafeCounter.class) 来确保线程安全。


二、ReentrantLock

今天没时间了,明天待续!

相关文章
|
20小时前
|
缓存 安全 Java
Java线程面试题含答案
Java线程面试题含答案
|
23小时前
|
Java
并发编程的艺术:Java线程与锁机制探索
【6月更文挑战第21天】**并发编程的艺术:Java线程与锁机制探索** 在多核时代,掌握并发编程至关重要。本文探讨Java中线程创建(`Thread`或`Runnable`)、线程同步(`synchronized`关键字与`Lock`接口)及线程池(`ExecutorService`)的使用。同时,警惕并发问题,如死锁和饥饿,遵循最佳实践以确保应用的高效和健壮。
7 2
|
21小时前
|
算法 安全 网络协议
java高级面试题_java面试题大全带答案_线程面试题_java面试宝典2019
java高级面试题_java面试题大全带答案_线程面试题_java面试宝典2019
|
21小时前
|
安全 算法 Java
java线程面试题_2019java面试题库
java线程面试题_2019java面试题库
|
1天前
|
安全 Java
JAVA多线程通信新解:wait()、notify()、notifyAll()的实用技巧
【6月更文挑战第20天】Java多线程中,`wait()`, `notify()`和`notifyAll()`用于线程通信。在生产者-消费者模型示例中,它们确保线程同步。`synchronized`保证安全,`wait()`在循环内防止虚假唤醒,`notifyAll()`避免唤醒单一线程问题。关键技巧包括:循环内调用`wait()`,优先使用`notifyAll()`以保证可靠性,以及确保线程安全和正确处理`InterruptedException`。
|
1天前
|
Java
当JAVA多线程遇上wait()和notify():一场奇妙的邂逅
【6月更文挑战第20天】JAVA多线程中,wait()和notify()是线程通信的关键。wait()让线程释放锁进入等待,直到被notify()或notifyAll()唤醒。它们用于协调如生产者-消费者问题中的线程协作,确保在同步块内调用,并伴随条件检查以防止虚假唤醒。示例代码展示了一个简单的共享队列,其中生产和消费使用wait/notify实现同步。
|
1天前
|
安全 Java
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
【6月更文挑战第20天】JAVA多线程中,wait(), notify(), notifyAll()是Object类的关键同步机制。wait()让线程等待并释放锁,直到被notify()或notifyAll()唤醒或超时。它们必须在同步块中使用,持有锁的线程调用。notify()唤醒一个等待线程,notifyAll()唤醒所有。最佳实践包括:与synchronized结合,循环检查条件,避免循环内notify(),通常优先使用notifyAll()。
|
1天前
|
Java
JAVA多线程通信:为何wait()与notify()如此重要?
【6月更文挑战第20天】Java多线程中,wait()和notify()是关键的通信工具,用于解决并发访问共享资源时的数据一致性。这些方法让线程能等待特定条件并高效唤醒,避免忙等待和响应延迟。例如,在生产者-消费者模型中,它们协调生产者和消费者的活动,当队列满或空时,线程调用wait()休眠,notifyAll()唤醒等待的线程,保证同步和资源有效利用。
|
1天前
|
Java
wait()和notify():JAVA多线程世界的“信号兵”
【6月更文挑战第20天】在Java多线程中,`wait()`和`notify()`作为Object类的方法,扮演着线程间协调者的角色。`wait()`让线程等待并释放锁,`notify()`或`notifyAll()`唤醒等待的线程。在生产者-消费者模型中,它们用于同步访问资源,例如队列。当队列满或空时,线程调用wait()暂停,另一方完成操作后用notify()唤醒。理解并正确使用这些“信号兵”对构建高效的多线程程序至关重要。
|
1天前
|
Java
那些年,我们一起学过的JAVA多线程通信
【6月更文挑战第20天】JAVA多线程通信,如同编程旅途中的一道风景,引导我们探索复杂与魅力。wait()是优雅的暂停,释放锁让其他线程继续;notify()唤醒一个,像老师点名,而notifyAll()唤醒全部。生产者-消费者模型中,wait()与notify()协调线程,教会我们合作与解决问题。那些并肩学习的日子,成为永恒的记忆。