Java线程的基础同步策略介绍

        关于线程中的同步策略，或者说是线程之间的协作，如何去进行？

        关于这个问题，我们自然想到Java中线程之间能够共享的在堆区和方法区，应该从这里入手比较好。而具体工具我们能想到啥呢？利用 锁、信号量、条件变量，CAS?具体如何做呢？我们这里从一个常见的问题来入手解决，进而了解在Java中线程的常见同步策略有哪些。

目录

问题描述

问题思考

问题解决

利用锁

条件变量

信号量

CAS思想

总结

---

---

问题描述

        使用两个线程交替打印出0-99的数字。

问题思考

        两个线程交替打印0-99的数字，说白了就是线程a打印0，2，4，....,98。线程b打印1，3，5，...,99。这不就是线程a打印偶数，线程b打印奇数嘛。有了这个结论，我们可以大致得出两个线程的打印结构。

//线程a
for (int i = 0; i < 100; i+=2) {
    System.out.println(Thread.currentThread().getName()+":"+i);
    TimeUnit.SECONDS.sleep(1);
    //同步策略
}


//线程b
for (int i = 0; i < 100; i+=2) {
    System.out.println(Thread.currentThread().getName()+":"+i);
    TimeUnit.SECONDS.sleep(1);
    //同步策略
}

问题解决

利用锁

        java中常用的锁机制有synchronized关键字和juc中的ReentrantLock锁。关于synchronized和juc中的ReentrantLock锁的差异我后面将出文具体说明，这里我们先用synchronized来解决这个问题。

        synchronized要锁住一个对象才行，常见的有锁住对象自己，锁住对象所属的类，这里我们新建一个Integer对象，作为锁的对象，于是我们能够写出这样的代码。

 Integer lock = new Integer(-1);
        new Thread(()->{
            synchronized (lock){
                try {
                    for (int i = 0; i < 100; i+=2) {
                        System.out.println(Thread.currentThread().getName()+":"+i);
                        TimeUnit.SECONDS.sleep(1);
                        lock.notify(); //唤醒另一个线程
                        lock.wait(); //阻塞自己，等待另一个线程唤醒
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"a").start();

        TimeUnit.MILLISECONDS.sleep(500); //因为两个线程的第一次打印只需要拿到锁而不需要唤醒。保证a线程先进入，即要先打印0        

        new Thread(()->{
            synchronized (lock){
                try {
                    for (int i = 1; i < 100; i+=2) {
                        System.out.println(Thread.currentThread().getName()+":"+i);
                        TimeUnit.SECONDS.sleep(1);
                        lock.notify();//唤醒另一个线程
                        lock.wait();//阻塞自己，等待另一个线程唤醒
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"b").start();

        这里有几个点要注意一下。

1. 中间的延迟是保证线程1线打印。
2. 其中要注意的是wait操作会提前释放锁，这样上面的程序才不会导致死锁，并且这种wait操作需要其他线程的notify操作或者notifyAll操作才能使得该线程被唤醒继续争取锁。

条件变量

        这里条件变量我们使用ReentrantLock对象获得，通过其newCondition方法。Java的条件变量这是也是JUC包下的。

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(()->{
    lock.lock();
        try {
            for (int i = 0; i < 100; i+=2) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                TimeUnit.SECONDS.sleep(1);
                condition.signal();//
                condition.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
         lock.unlock();
        }
},"a").start();

TimeUnit.MILLISECONDS.sleep(500); //同样地原因

new Thread(()->{
    lock.lock();
        try {
            for (int i = 1; i < 100; i+=2) {
                System.out.println(Thread.currentThread().getName()+":"+i);
                TimeUnit.SECONDS.sleep(1);
                condition.signal();
                condition.await();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
},"b").start();

        其实类似于直接使用锁，只是条件变量的适用范围更广泛，可以在同一个代码块中，优雅地实现多个条件的线程挂起与唤醒操作。

信号量

        Java中也可以使用JUC包中的Semaphore，其底层与ReentrantLock一样也是AQS思想。不过Semaphore是共享模式，ReentrantLock底层是独占模式。关于相关底层数据结构的有时间我会在后期进行一个源码剖析比较。这里我们直接上解决方案。

Semaphore semaphore1 = new Semaphore(1); //更简单一些，不需要时间延迟，代表线程a先开始
Semaphore semaphore2 = new Semaphore(0); //线程b一开始为0，即使先进入也得阻塞
new Thread(()->{
    for (int i = 0; i < 100; i+=2) {
        try {
            semaphore1.acquire();//消耗，初始或线程b提供
            System.out.println(Thread.currentThread().getName()+":"+i);
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semaphore2.release();//生产，生产给线程b
        }
    }
},"a").start();
new Thread(()->{
    for (int i = 1; i < 100; i+=2) {
        try {
            semaphore2.acquire(); //消耗，线程a提供
            System.out.println(Thread.currentThread().getName()+":"+i);
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            semaphore1.release();//生产，生产给线程a
        }
    }
},"b").start();

        有没有感觉信号量方式的程序实现方式非常的明亮简洁？这里使用的acquire方法和release方法分别代表消耗和生产——这其实能够非常好地模拟生产-消费者模型。两个信号量代表两个标识，每个线程执行前需要消耗这个标识，消耗完成后会提供给另一个线程对应的标识，完成同步操作。

CAS思想

        我们直到CAS思想其实就是乐观锁的思想，已经在很多数据结构上有运用，比如ConcurrentHashMap，ConcurentLinkedDeque等，其中JUC的原子类更是运用了该思想，我们这里就用AtomicInteger来实现这个解决方案。

private static volatile boolean flag=false; //可见性问题，写回主内存
private static void method1(){ //CAS
    AtomicInteger atomicInteger = new AtomicInteger(1);
    new Thread(()->{
        while(atomicInteger.get()<100){ //自旋
            if(flag==true&&atomicInteger.get()%2==0){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+atomicInteger.getAndIncrement());
                flag=false;
            }
        }
    },"a").start();
    new Thread(()->{
        while(atomicInteger.get()<100){//自旋
            if(flag==false&&atomicInteger.get()%2==1){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+atomicInteger.getAndIncrement());
                flag=true;
            }
        }
    },"b").start();
}

总结

        线程的通信机制除了简单的join插队，yield让步之外，还能有更多的策略进行通信，不过最底层还是要追溯到java中线程中共享的机制，即能够共享堆区和方法区。基于此才出现了各式各样的方法。