Java多线程之synchronized的小介绍

350 阅读3分钟

首先先看看下面的代码:

public class checkSynchronized extends Thread{
    static volatile int i = 0;
    
    public static void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
    }
    
    public static void main(String args[]) throws InterruptedException {
        Thread t1 = new checkSynchronized();
        Thread t2 = new checkSynchronized();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("i : " + i);
    }
}

执行上述代码,你会发现大部分情况下i的最终值都会小于2000000的

为什么加了volatile关键词的变量依旧会出现线程安全问题呢?

这是因为volatile只保证可见性,不保证原子性

图为两条线程同时对i进行写入时,一个线程的结果会覆盖另一线程的结果,造成线程安全问题。 解决此问题就应该在线程甲进行写入值时,线程乙不仅不能写入、而且还不能读取值,如果读取值的话就会读取到一个旧值,依旧会造成线程安全问题。那该如何实现呢?

在这里就要引出今天的主角了:"Synchronized"

关键字synchronized的作用就是实现线程间的同步问题,它能将同步区的代码进行加锁,一次只能允许一条线程进入同步区,以保证同步区中的线程安全问题。 下面就来测试下该关键字的作用:

public class checkSynchronized extends Thread{
    Object lock;
    checkSynchronized(Object lock) {
        this.lock = lock;
    }
    static volatile int i = 0;

    public static void increase() {
        i++;
    }

    @Override
    public void run() {
        synchronized (lock) {
            for (int j = 0; j < 1000000; j++) {
                increase();
            }
        }
    }

    public static void main(String args[]) throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new checkSynchronized(lock);
        Thread t2 = new checkSynchronized(lock);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("i : " + i);
    }
}

大家可以看到在run()方法里加了synchronized,并且指定了锁对象。

运行结果:i : 2000000

在这里简单地整理下synchronized的多种用法:

  • 指定锁对象,进入前须先获得给定对象的锁(如上述代码所述)
  • 加在实例方法,进入前须获得当前实例的锁
  • 加在静态方法,进入前须获得当前类的锁

在这里给出一段错误代码,大家需要明白:

public static void main(String args[]) throws InterruptedException {
        Object lock1 = new Object();    //生成第一个锁
        Object lock2 = new Object();    //生成第二个锁
        Thread t1 = new checkSynchronized(lock1);
        Thread t2 = new checkSynchronized(lock2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("i : " + i);
    }

这段代码表示出各自线程最终使用了各自的锁,线程安全是无法保证的。

对于作用在实例方法上的也要注意,因为其可能会发生和上述相同原因的线程安全错误。

public class checkSynchronized implements Runnable{

    static volatile int i = 0;

    public synchronized void increase() {
        i++;
    }

    @Override
    public void run() {
        for (int j = 0; j < 1000000; j++) {
            increase();
        }
    }

    public static void main(String args[]) throws InterruptedException {
        checkSynchronized onlyOne = new checkSynchronized();
        Thread t1 = new Thread(onlyOne);
        Thread t2 = new Thread(onlyOne);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("i : " + i);
    }
}

上述代码的synchronized作用在实例方法上,锁为当前实例。所以在main方法中只实例了一个checkSynchronized实例,因为锁只需要一个、多了就会出现安全问题。

如果实例了两个对象,则会出现安全问题(锁多了和不加锁就没啥区别了),如下述代码:

public static void main(String args[]) throws InterruptedException {
        checkSynchronized onlyOne = new checkSynchronized();
        checkSynchronized wrong = new checkSynchronized();
        Thread t1 = new Thread(onlyOne);
        Thread t2 = new Thread(wrong);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("i : " + i);
    }

解决的办法非常容易,只需在加了锁的实例方法加上"static"关键字就行。

public static synchronized void increase() 这样锁就作用在类方法上了。当线程要执行该同步方法时是请求当前类的锁并非实例的锁,所以再多的实例线程之间依旧能正确同步。

synchronized不仅用于线程同步、确保线程安全问题外,还能保证线程之间的可见性和有序性问题。相当于是volatile的升级版。但被synchronized限制的多线程之间是串行执行的,所带来的性能消耗是很大的。