Java多线程之synchronized的小介绍

首先先看看下面的代码：

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限制的多线程之间是串行执行的，所带来的性能消耗是很大的。