Java-多线程之线程同步

线程同步

多个线程同时运行的时候，现场的调度是由操作系统决定的，程序本身无法决定。当多个线程同时读写一个变量的时候，就有可能出现问题。即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。

所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法。

示例：

我们定义一个AddThread线程和一个DecThread线程，它们分别对一个count变量循环添加100次，再循环减少100次，最终变量的结果应该为0。

代码如下：

class AddThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < SynchronizedTest.LOOP; i++) {
            SynchronizedTest.count += 1;
        }
    }
}

class DecThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < SynchronizedTest.LOOP; i++) {
            SynchronizedTest.count -= 1;
        }
    }
}

public class SynchronizedTest {
    final static int LOOP = 10000;
    public static int count = 0;
    public static void main(String[] args) throws Exception{
        Thread t1 = new AddThread();
        Thread t2 = new DecThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果：

可见结果不可预见，每次都不一样

对共享变量进行写入时，必须保证是原子操作，原子操作是指不能被中断的一个或一系列操作。

例如【n=n+1;】这条语句，就会被编译器拆分成三条指令，如下图所示：

既然可拆分就不是原子操作，就有可能被其它线程中断，进而修改共享变量。

那什么是原子操作呢?

JVM规范定义了几种原子操作

• 基本类型（long和double除外）赋值：

int = 100;

• 引用类型赋值：

List<String> list = anotherList;

那如果对变量的操作是非原子操作，如何保持同步呢？

使用synchronized方法对指定对象加锁

class AddThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < SynchronizedTest.LOOP; i++) {
            // 加锁对象必须是同一个实例
            synchronized (SynchronizedTest.LOCK){
                SynchronizedTest.count += 1;
            }
        }
    }
}

class DecThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < SynchronizedTest.LOOP; i++) {
            // 加锁对象必须是同一个实例
            synchronized (SynchronizedTest.LOCK){
                SynchronizedTest.count -= 1;
            }
        }
    }
}

public class SynchronizedTest {
    final static int LOOP = 10000;
    public static int count = 0;
    final static Object LOCK = new Object();
    public static void main(String[] args) throws Exception{
        Thread t1 = new AddThread();
        Thread t2 = new DecThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
    }
}

运行结果：

总结：

多线程同时修改变量会造成逻辑错误。

• 需要通过synchronized同步
• 同步的本质就是给指定对象加锁
• 注意加锁对象必须是同一个实例

对jvm定义的单个原子操作不需要同步

使用synchronized对一个对象加锁不用担心异常发生，无论有无异常发生，结束时都会释放锁。

synchronized代码块无法并发执行，因此程序的性能会下降。而且加锁和解锁都需要消耗时间，会降低程序的执行效率。（synchronized以牺牲性能来获取程序一致性）