Java concurrency之互斥锁_动力节点Java学院整理

Java Concurrency之互斥锁

什么是互斥锁

互斥锁是一种独占锁，同一时刻只能被一个线程持有，其他线程需要等待该线程释放锁后才能获取。在需要修改共享变量的情况下，使用互斥锁能够保证并发修改不会造成数据的错乱。

Java中的互斥锁是通过synchronized进行实现的。synchronized分为两种使用方式：对象锁和类锁。

对象锁

对象锁作用于某个对象实例，同一时间只能有一个线程持有该对象实例的锁，其他需要获取该对象实例的锁的线程需要等待锁的释放。

示例代码：

public class MyThread implements Runnable {
    private int count;

    public synchronized void addCount() { // 获取对象锁
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            count++;
            System.out.println(Thread.currentThread().getName() + " count=" + count);
        }
    }

    @Override
    public void run() {
        addCount();
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread, "A");
        Thread t2 = new Thread(myThread, "B");
        t1.start();
        t2.start();
    }
}

在上述例子中，MyThread类的addCount方法前面加上了synchronized关键字，这样就获取到了对象锁。当A线程执行addCount方法时，B线程需要等待A线程释放对象锁后才能获取锁并执行addCount方法。

类锁

类锁作用于某个类的Class对象上，同一时间只能有一个线程持有该类的Class对象上的锁，其他需要获取该类锁的线程需要等待锁的释放。

示例代码：

public class MyThread implements Runnable {
    private static int count;

    public void addCount() {
        synchronized (MyThread.class) { // 获取类锁
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count++;
                System.out.println(Thread.currentThread().getName() + " count=" + count);
            }
        }
    }

    @Override
    public void run() {
        addCount();
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread, "A");
        Thread t2 = new Thread(myThread, "B");
        t1.start();
        t2.start();
    }
}

在上述例子中，MyThread类的addCount方法中，使用了类锁synchronized(MyThread.class)。当A线程执行addCount方法时，B线程需要等待A线程释放类锁后才能获取锁并执行addCount方法。

以上便是Java Concurrency之互斥锁的介绍。