学习wait、notify和synchronized及Lock

 概  述

1. 多线程同步相关java封装类：java.util.concurrent.locks. 包下；
    1）线程的生命周期：初始化、就绪、运行、阻塞、死亡
    2）Java中对线程定义的6种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED
    3）线程的状态转换过程
      从 NEW到 RUNNABLE状态
      NEW状态的线程，不会被操作系统调度，因此不会执行。Java线程要执行，就必须转换到 RUNNABLE状态。从NEW转到RUNNABLE状态，只要调用线程对象的start()方法就可以了。
      从 RUNNABLE 到 TERMINATED 状态
      线程执行完run()方法后，会自动转换到 TERMINATED 状态；当然如果执行run()方法的时候异常抛出，也会导致线程终止；有时我们需要强制中断run()方法的执行，例如run()方法访问一个很慢的网络，我们想终止怎么办呢？Java的Thread类里面有个stop()方法，不过已经标记为 @Deprecated，所以不建议使用了。正确的姿势其实是调用interrupt()方法。
      stop()方法会真的杀死线程，不给线程喘息的机会，如果线程持有 ReentrantLock 锁，被 stop() 的线程并不会自动调用ReentrantLock的unlock()去释放锁，那其他线程就再也没机会获得 ReentrantLock 锁，这实在是太危险了。所以该方法就不建议使用了，类似的方法还有 suspend() 和 resume() 方法，这两个方法同样也都不建议使用了，所以这里也就不多介绍了。
      而interrupt() 方法就温柔多了，interrupt()方法仅仅是通知线程，线程有机会执行一些后续操作，同时也可以无视这个通知。被interrupt的线程，是怎么收到通知的呢？一种是异常，另一种是主动检测。
2. 关于Lock接口
    1）获取锁
       lock()     无返回值
       tryLock()   有返回值
       tryLock(long time, TimeUnit unit)   在一定时间内获取锁
       lockInterruptibly()  未获取到锁，会响应中断(抛出异常)
    2）释放锁
       unLock()
    3）实现类
       ReentrantLock: 可重入锁 唯一实现Lock接口
3. 关于ReadWriteLock(读写锁)接口
    如果有一个线程已经占用了读锁，则此时其他线程要申请读锁，也可以同时获取到读锁。
    如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。
    如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。    
    1）获取锁
        readLock()  获取读锁
        writeLock()  获取写锁
    2）释放锁
        readLock().unLock()  释放读锁
        writeLock().unLock()  释放写锁
    3）实现类
       ReentrantReadWriteLock: 可重入锁 唯一实现Lock接口
4. 相关概念
    1）. 可重入锁
    如果锁具备可重入性，则称作为可重入锁。像synchronized和ReentrantLock都是可重入锁，
    可重入性实际上表明了锁的分配机制：基于线程的分配，而不是基于方法调用的分配。
    举个简单的例子，当一个线程执行到某个synchronized方法时，比如说method1，而在method1中会调用另外一个synchronized方法method2，此时线程不必重新去申请锁，而是可以直接执行方法method2。
    简单的理解：线程已经具备锁，不必再申请锁，可一直执行完毕。
    2）. 可中断锁
    在Java中，synchronized就不是可中断锁，而Lock是可中断锁。
    3）. 公平锁
    公平锁即尽量以请求锁的顺序来获取锁。
    synchronized就是非公平锁，它无法保证等待的线程获取锁的顺序。
    而对于ReentrantLock和ReentrantReadWriteLock，它默认情况下是非公平锁，但是可以设置为公平锁。
    ReentrantLock中静态内部类：1）NotFairSync实现非公平锁；2）FairSync实现公平锁
    ReentrantLock lock = new ReentrantLock(true); 参数为true表示为公平锁，为fasle为非公平锁
    4）. 读写锁
    正因为有了读写锁，才使得多个线程之间的读操作不会发生冲突。
     ReadWriteLock就是读写锁，它是一个接口，ReentrantReadWriteLock实现了这个接口。
     可以通过readLock()获取读锁，通过writeLock()获取写锁。
5. Lock和synchronized的区别
    1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；
    2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；
       而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，
       因此使用Lock时需要在finally块中释放锁；
    3）Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，
       等待的线程会一直等待下去，不能够响应中断；
    4）通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
    5）Lock可以提高多个线程进行读操作的效率。
    在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），
    此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。
6. Object下的锁：
    wait():释放占有的对象锁
    notify(): 该方法会唤醒因为调用对象的wait()而等待的线程
    notifyAll()则是唤醒所有等待的线程

  一、 java多线程同步：synchronized及wait()、notify()

import java.util.Random;
import java.util.concurrent.*;

public class MyProductAndConsume {

    volatile static int NUM = 1;

    AtomicInteger atomicInteger = new AtomicInteger(0);

    final Object productLock = Object.class;
    final Object consumeLock = int[].class;
    final ReentrantLock lock = new ReentrantLock();

    final class MyWorkProduct implements Callable {
        public Object call() throws Exception{
            while (true) {
                Thread.sleep(500);
                synchronized (atomicInteger) {
                    while (atomicInteger.get() >= 1)  //已有生产的产品（while是为了同时只能一个生产者工作）
                        atomicInteger.wait(); //阻塞当前线程
                    System.out.println(Thread.currentThread().getName() + "-MyWorkProduct : " + ++NUM);
                    atomicInteger.incrementAndGet();
                    atomicInteger.notifyAll();
                }
            }
        }
    }

    final class MyWorkConsume implements Callable {
        public Object call() throws Exception{
            while (true) {
                Thread.sleep(new Random().nextInt(8000) + 500);
                synchronized (atomicInteger) {
                    while (atomicInteger.get() <= 0)  //无可消费产品（while是为了同时只能一个消费者消费）
                        atomicInteger.wait();
                    System.out.println(Thread.currentThread().getName() + "-MyWorkConsume : " + NUM);
                    atomicInteger.getAndDecrement();
                    atomicInteger.notifyAll();
                }
            }
        }
    }

    public void execute() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.submit(new MyWorkProduct());executorService.submit(new MyWorkProduct());
        executorService.submit(new MyWorkConsume());executorService.submit(new MyWorkConsume());executorService.submit(new MyWorkConsume());
    }

    public static void main(String[] args) {
        new MyProductAndConsume().execute();
    }
}

运行结果：

pool-1-thread-2-MyWorkProduct : 2
pool-1-thread-3-MyWorkConsume : 2
pool-1-thread-2-MyWorkProduct : 3
pool-1-thread-4-MyWorkConsume : 3
pool-1-thread-1-MyWorkProduct : 4
pool-1-thread-5-MyWorkConsume : 4
pool-1-thread-1-MyWorkProduct : 5
pool-1-thread-3-MyWorkConsume : 5
pool-1-thread-1-MyWorkProduct : 6
pool-1-thread-5-MyWorkConsume : 6
pool-1-thread-2-MyWorkProduct : 7
pool-1-thread-4-MyWorkConsume : 7
pool-1-thread-1-MyWorkProduct : 8
pool-1-thread-4-MyWorkConsume : 8
pool-1-thread-1-MyWorkProduct : 9
pool-1-thread-4-MyWorkConsume : 9
pool-1-thread-1-MyWorkProduct : 10
pool-1-thread-3-MyWorkConsume : 10
…………

 示例二：

package com.cheng2839.test;

import com.cheng2839.util.Logger;

/**
 * java多线程同步
 * 1. synchronized修饰方法[参见syncFunOne]
 * 2. synchronized同步块(普通类成员变量)[参见syncFunTwo]
 * 3. synchronized同步块(static类成员变量)[参见syncFunThree]
 * 4. wait()及notify()的用法[参见syncFunFour1、syncFunFour2]
 *
 * @author cheng2839
 * @date 2018年11月16日
 */
public class MyThreadTest001 {

    //此处定义一个静态类成员变量，供所有线程共用[共用信号量]
    public static int NUM;

    //Object成员变量
    private Object lock = new Object();

    //Object静态类成员变量
    private static final Object LOCK = new Object();

    //初始化信号量值
    public MyThreadTest001() {
        NUM = 1;
    }

    /**
     * synchronize修饰的方法，表示该方法是同步的
     */
    public synchronized void syncFunOne() {
        Logger.info(Thread.currentThread()+" - syncFunOne before : " + NUM);
        NUM++;
        Logger.info(Thread.currentThread()+" - syncFunOne after : " + NUM);
    }

    /**
     * synchronize修饰的代码块，表示该方法中被synchronized修饰的代码块是同步的
     */
    public void syncFunTwo() {
        synchronized(lock) {
            Logger.info(Thread.currentThread()+" - syncFunTwo before : " + NUM);
            NUM++;
            Logger.info(Thread.currentThread()+" - syncFunTwo after : " + NUM);
        }
    }

    /**
     * synchronize修饰的代码块，表示该方法中被synchronized修饰的代码块是同步的
     */
    public void syncFunThree() {
        synchronized(LOCK) {
            Logger.info(Thread.currentThread()+" - syncFunThree before : " + NUM);
            NUM++;
            Logger.info(Thread.currentThread()+" - syncFunThree after : " + NUM);
        }
    }

    /**
     * lock.wait()表示等待被lock对象实例的notify()唤醒，才可继续执行
     * 注意：使用wait()必须被synchronized修饰
     *       wait()和notify()配对使用，表示在执行上有先后顺序
     */
    public void syncFunFour1() {
        try {
            while (true) {
                synchronized (lock) {
                    lock.wait(); //等待被唤醒
                    Logger.info(Thread.currentThread()+" - syncFunFour1 before : " + NUM);
                    NUM++;
                    Logger.info(Thread.currentThread()+" - syncFunFour1 after : " + NUM);
                }
            }
        }catch (InterruptedException e){}
    }

    /**
     * lock.notify()表示实例唤醒一个被lock对象wait()的线程
     * 注意：使用notify()必须被synchronized修饰
     *       wait()和notify()配对使用，表示在执行上有先后顺序
     */
    public void syncFunFour2() {
        try {
            while (true) {
                synchronized (lock) {
                    Logger.info(Thread.currentThread()+" - syncFunFour2 before : " + NUM);
                    NUM--;
                    Logger.info(Thread.currentThread()+" - syncFunFour2 after : " + NUM);
                    lock.notify(); //唤醒一个wait的线程
                }
                Logger.info(Thread.currentThread()+" - sleep beginning.");
                Thread.sleep(3000);
                Logger.info(Thread.currentThread()+" - sleep finished.");
            }
        }catch (InterruptedException e){}
    }

    /**
     * 测试wait()和notify()
     * @param test001
     */
    public void testWait(MyThreadTest001 test001){
        //执行顺序是：对信号量先减1，再唤醒加1线程，每3秒循环执行一次
        new Thread(() -> test001.syncFunFour1()).start(); //对信号量进行加1操作
        new Thread(() -> test001.syncFunFour2()).start(); //对信号量进行减1操作
    }


    public static void main(String[] args) {
        MyThreadTest001 test001 = new MyThreadTest001();

        //测试synchronized
        //创建threadCount个线程，对同一信号量进行加1操作，保证信号量同时只被一个线程操作，保证了信号量的一致性
        int threadCount = 5;
        while (threadCount-->0) {
            Thread thread = new Thread(new TestThread(test001));
            thread.start();
        }

        //测试wait()和notify()
//        test001.testWait(test001);

    }
}

/**
 * 创建一个线程
 */
class TestThread implements Runnable{
    private MyThreadTest001 test001;
    public TestThread(MyThreadTest001 test001) {
        this.test001 = test001;
    }
    public void run() {
        try {
            //每个线程每隔50毫秒并循环调用5次
            for (int i=0;i<5;i++) {
                test001.syncFunOne(); //此处可以切换为syncFunTwo、syncFunThree进行测试
//                test001.syncFunTwo();
//                test001.syncFunThree();
                Thread.sleep(50);
            }
        }catch (InterruptedException e) {}
    }
}

  测试打印结果：

--------------------测试syncFunOne()的打印结果如下--------------------
2018-11-16 23:08:56.047    [INFO]    Thread[Thread-0,5,main] - syncFunOne before : 1
2018-11-16 23:08:56.048    [INFO]    Thread[Thread-0,5,main] - syncFunOne after : 2
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-4,5,main] - syncFunOne before : 2
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-4,5,main] - syncFunOne after : 3
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-3,5,main] - syncFunOne before : 3
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-3,5,main] - syncFunOne after : 4
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-2,5,main] - syncFunOne before : 4
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-2,5,main] - syncFunOne after : 5
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-1,5,main] - syncFunOne before : 5
2018-11-16 23:08:56.049    [INFO]    Thread[Thread-1,5,main] - syncFunOne after : 6
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-2,5,main] - syncFunOne before : 6
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-2,5,main] - syncFunOne after : 7
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-0,5,main] - syncFunOne before : 7
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-0,5,main] - syncFunOne after : 8
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-3,5,main] - syncFunOne before : 8
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-3,5,main] - syncFunOne after : 9
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-4,5,main] - syncFunOne before : 9
2018-11-16 23:08:56.100    [INFO]    Thread[Thread-4,5,main] - syncFunOne after : 10
2018-11-16 23:08:56.101    [INFO]    Thread[Thread-1,5,main] - syncFunOne before : 10
2018-11-16 23:08:56.101    [INFO]    Thread[Thread-1,5,main] - syncFunOne after : 11
2018-11-16 23:08:56.151    [INFO]    Thread[Thread-3,5,main] - syncFunOne before : 11
2018-11-16 23:08:56.151    [INFO]    Thread[Thread-3,5,main] - syncFunOne after : 12
2018-11-16 23:08:56.151    [INFO]    Thread[Thread-2,5,main] - syncFunOne before : 12
2018-11-16 23:08:56.151    [INFO]    Thread[Thread-2,5,main] - syncFunOne after : 13
2018-11-16 23:08:56.151    [INFO]    Thread[Thread-0,5,main] - syncFunOne before : 13
2018-11-16 23:08:56.151    [INFO]    Thread[Thread-0,5,main] - syncFunOne after : 14
2018-11-16 23:08:56.152    [INFO]    Thread[Thread-4,5,main] - syncFunOne before : 14
2018-11-16 23:08:56.152    [INFO]    Thread[Thread-4,5,main] - syncFunOne after : 15
2018-11-16 23:08:56.152    [INFO]    Thread[Thread-1,5,main] - syncFunOne before : 15
2018-11-16 23:08:56.152    [INFO]    Thread[Thread-1,5,main] - syncFunOne after : 16
2018-11-16 23:08:56.202    [INFO]    Thread[Thread-0,5,main] - syncFunOne before : 16
2018-11-16 23:08:56.202    [INFO]    Thread[Thread-0,5,main] - syncFunOne after : 17
2018-11-16 23:08:56.202    [INFO]    Thread[Thread-2,5,main] - syncFunOne before : 17
2018-11-16 23:08:56.202    [INFO]    Thread[Thread-2,5,main] - syncFunOne after : 18
2018-11-16 23:08:56.202    [INFO]    Thread[Thread-3,5,main] - syncFunOne before : 18
2018-11-16 23:08:56.202    [INFO]    Thread[Thread-3,5,main] - syncFunOne after : 19
2018-11-16 23:08:56.203    [INFO]    Thread[Thread-4,5,main] - syncFunOne before : 19
2018-11-16 23:08:56.203    [INFO]    Thread[Thread-4,5,main] - syncFunOne after : 20
2018-11-16 23:08:56.203    [INFO]    Thread[Thread-1,5,main] - syncFunOne before : 20
2018-11-16 23:08:56.203    [INFO]    Thread[Thread-1,5,main] - syncFunOne after : 21
2018-11-16 23:08:56.253    [INFO]    Thread[Thread-0,5,main] - syncFunOne before : 21
2018-11-16 23:08:56.253    [INFO]    Thread[Thread-0,5,main] - syncFunOne after : 22
2018-11-16 23:08:56.253    [INFO]    Thread[Thread-2,5,main] - syncFunOne before : 22
2018-11-16 23:08:56.253    [INFO]    Thread[Thread-2,5,main] - syncFunOne after : 23
2018-11-16 23:08:56.253    [INFO]    Thread[Thread-3,5,main] - syncFunOne before : 23
2018-11-16 23:08:56.253    [INFO]    Thread[Thread-3,5,main] - syncFunOne after : 24
2018-11-16 23:08:56.254    [INFO]    Thread[Thread-4,5,main] - syncFunOne before : 24
2018-11-16 23:08:56.254    [INFO]    Thread[Thread-4,5,main] - syncFunOne after : 25
2018-11-16 23:08:56.254    [INFO]    Thread[Thread-1,5,main] - syncFunOne before : 25
2018-11-16 23:08:56.254    [INFO]    Thread[Thread-1,5,main] - syncFunOne after : 26


--------------------测试syncFunTwo()的打印结果如下--------------------
2018-11-16 23:09:24.966    [INFO]    Thread[Thread-0,5,main] - syncFunTwo before : 1
2018-11-16 23:09:24.966    [INFO]    Thread[Thread-0,5,main] - syncFunTwo after : 2
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-4,5,main] - syncFunTwo before : 2
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-4,5,main] - syncFunTwo after : 3
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-3,5,main] - syncFunTwo before : 3
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-3,5,main] - syncFunTwo after : 4
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-2,5,main] - syncFunTwo before : 4
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-2,5,main] - syncFunTwo after : 5
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-1,5,main] - syncFunTwo before : 5
2018-11-16 23:09:24.967    [INFO]    Thread[Thread-1,5,main] - syncFunTwo after : 6
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-3,5,main] - syncFunTwo before : 6
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-3,5,main] - syncFunTwo after : 7
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-1,5,main] - syncFunTwo before : 7
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-1,5,main] - syncFunTwo after : 8
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-2,5,main] - syncFunTwo before : 8
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-2,5,main] - syncFunTwo after : 9
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-0,5,main] - syncFunTwo before : 9
2018-11-16 23:09:25.018    [INFO]    Thread[Thread-0,5,main] - syncFunTwo after : 10
2018-11-16 23:09:25.019    [INFO]    Thread[Thread-4,5,main] - syncFunTwo before : 10
2018-11-16 23:09:25.019    [INFO]    Thread[Thread-4,5,main] - syncFunTwo after : 11
2018-11-16 23:09:25.069    [INFO]    Thread[Thread-1,5,main] - syncFunTwo before : 11
2018-11-16 23:09:25.069    [INFO]    Thread[Thread-1,5,main] - syncFunTwo after : 12
2018-11-16 23:09:25.069    [INFO]    Thread[Thread-3,5,main] - syncFunTwo before : 12
2018-11-16 23:09:25.069    [INFO]    Thread[Thread-3,5,main] - syncFunTwo after : 13
2018-11-16 23:09:25.069    [INFO]    Thread[Thread-2,5,main] - syncFunTwo before : 13
2018-11-16 23:09:25.069    [INFO]    Thread[Thread-2,5,main] - syncFunTwo after : 14
2018-11-16 23:09:25.070    [INFO]    Thread[Thread-0,5,main] - syncFunTwo before : 14
2018-11-16 23:09:25.070    [INFO]    Thread[Thread-0,5,main] - syncFunTwo after : 15
2018-11-16 23:09:25.070    [INFO]    Thread[Thread-4,5,main] - syncFunTwo before : 15
2018-11-16 23:09:25.070    [INFO]    Thread[Thread-4,5,main] - syncFunTwo after : 16
2018-11-16 23:09:25.120    [INFO]    Thread[Thread-1,5,main] - syncFunTwo before : 16
2018-11-16 23:09:25.120    [INFO]    Thread[Thread-1,5,main] - syncFunTwo after : 17
2018-11-16 23:09:25.120    [INFO]    Thread[Thread-2,5,main] - syncFunTwo before : 17
2018-11-16 23:09:25.120    [INFO]    Thread[Thread-2,5,main] - syncFunTwo after : 18
2018-11-16 23:09:25.120    [INFO]    Thread[Thread-3,5,main] - syncFunTwo before : 18
2018-11-16 23:09:25.120    [INFO]    Thread[Thread-3,5,main] - syncFunTwo after : 19
2018-11-16 23:09:25.121    [INFO]    Thread[Thread-4,5,main] - syncFunTwo before : 19
2018-11-16 23:09:25.121    [INFO]    Thread[Thread-4,5,main] - syncFunTwo after : 20
2018-11-16 23:09:25.121    [INFO]    Thread[Thread-0,5,main] - syncFunTwo before : 20
2018-11-16 23:09:25.121    [INFO]    Thread[Thread-0,5,main] - syncFunTwo after : 21
2018-11-16 23:09:25.171    [INFO]    Thread[Thread-3,5,main] - syncFunTwo before : 21
2018-11-16 23:09:25.171    [INFO]    Thread[Thread-3,5,main] - syncFunTwo after : 22
2018-11-16 23:09:25.171    [INFO]    Thread[Thread-1,5,main] - syncFunTwo before : 22
2018-11-16 23:09:25.171    [INFO]    Thread[Thread-1,5,main] - syncFunTwo after : 23
2018-11-16 23:09:25.171    [INFO]    Thread[Thread-2,5,main] - syncFunTwo before : 23
2018-11-16 23:09:25.171    [INFO]    Thread[Thread-2,5,main] - syncFunTwo after : 24
2018-11-16 23:09:25.172    [INFO]    Thread[Thread-4,5,main] - syncFunTwo before : 24
2018-11-16 23:09:25.172    [INFO]    Thread[Thread-4,5,main] - syncFunTwo after : 25
2018-11-16 23:09:25.172    [INFO]    Thread[Thread-0,5,main] - syncFunTwo before : 25
2018-11-16 23:09:25.172    [INFO]    Thread[Thread-0,5,main] - syncFunTwo after : 26

--------------------测试syncFunThree()的打印结果如下--------------------
2018-11-16 23:09:43.712    [INFO]    Thread[Thread-0,5,main] - syncFunThree before : 1
2018-11-16 23:09:43.713    [INFO]    Thread[Thread-0,5,main] - syncFunThree after : 2
2018-11-16 23:09:43.713    [INFO]    Thread[Thread-4,5,main] - syncFunThree before : 2
2018-11-16 23:09:43.713    [INFO]    Thread[Thread-4,5,main] - syncFunThree after : 3
2018-11-16 23:09:43.713    [INFO]    Thread[Thread-3,5,main] - syncFunThree before : 3
2018-11-16 23:09:43.713    [INFO]    Thread[Thread-3,5,main] - syncFunThree after : 4
2018-11-16 23:09:43.714    [INFO]    Thread[Thread-2,5,main] - syncFunThree before : 4
2018-11-16 23:09:43.714    [INFO]    Thread[Thread-2,5,main] - syncFunThree after : 5
2018-11-16 23:09:43.714    [INFO]    Thread[Thread-1,5,main] - syncFunThree before : 5
2018-11-16 23:09:43.714    [INFO]    Thread[Thread-1,5,main] - syncFunThree after : 6
2018-11-16 23:09:43.764    [INFO]    Thread[Thread-4,5,main] - syncFunThree before : 6
2018-11-16 23:09:43.764    [INFO]    Thread[Thread-4,5,main] - syncFunThree after : 7
2018-11-16 23:09:43.764    [INFO]    Thread[Thread-0,5,main] - syncFunThree before : 7
2018-11-16 23:09:43.764    [INFO]    Thread[Thread-0,5,main] - syncFunThree after : 8
2018-11-16 23:09:43.765    [INFO]    Thread[Thread-1,5,main] - syncFunThree before : 8
2018-11-16 23:09:43.765    [INFO]    Thread[Thread-1,5,main] - syncFunThree after : 9
2018-11-16 23:09:43.765    [INFO]    Thread[Thread-2,5,main] - syncFunThree before : 9
2018-11-16 23:09:43.765    [INFO]    Thread[Thread-2,5,main] - syncFunThree after : 10
2018-11-16 23:09:43.765    [INFO]    Thread[Thread-3,5,main] - syncFunThree before : 10
2018-11-16 23:09:43.765    [INFO]    Thread[Thread-3,5,main] - syncFunThree after : 11
2018-11-16 23:09:43.814    [INFO]    Thread[Thread-4,5,main] - syncFunThree before : 11
2018-11-16 23:09:43.814    [INFO]    Thread[Thread-4,5,main] - syncFunThree after : 12
2018-11-16 23:09:43.814    [INFO]    Thread[Thread-0,5,main] - syncFunThree before : 12
2018-11-16 23:09:43.814    [INFO]    Thread[Thread-0,5,main] - syncFunThree after : 13
2018-11-16 23:09:43.815    [INFO]    Thread[Thread-1,5,main] - syncFunThree before : 13
2018-11-16 23:09:43.815    [INFO]    Thread[Thread-1,5,main] - syncFunThree after : 14
2018-11-16 23:09:43.815    [INFO]    Thread[Thread-3,5,main] - syncFunThree before : 14
2018-11-16 23:09:43.815    [INFO]    Thread[Thread-3,5,main] - syncFunThree after : 15
2018-11-16 23:09:43.815    [INFO]    Thread[Thread-2,5,main] - syncFunThree before : 15
2018-11-16 23:09:43.815    [INFO]    Thread[Thread-2,5,main] - syncFunThree after : 16
2018-11-16 23:09:43.865    [INFO]    Thread[Thread-4,5,main] - syncFunThree before : 16
2018-11-16 23:09:43.865    [INFO]    Thread[Thread-4,5,main] - syncFunThree after : 17
2018-11-16 23:09:43.865    [INFO]    Thread[Thread-0,5,main] - syncFunThree before : 17
2018-11-16 23:09:43.865    [INFO]    Thread[Thread-0,5,main] - syncFunThree after : 18
2018-11-16 23:09:43.866    [INFO]    Thread[Thread-2,5,main] - syncFunThree before : 18
2018-11-16 23:09:43.866    [INFO]    Thread[Thread-2,5,main] - syncFunThree after : 19
2018-11-16 23:09:43.866    [INFO]    Thread[Thread-1,5,main] - syncFunThree before : 19
2018-11-16 23:09:43.866    [INFO]    Thread[Thread-1,5,main] - syncFunThree after : 20
2018-11-16 23:09:43.866    [INFO]    Thread[Thread-3,5,main] - syncFunThree before : 20
2018-11-16 23:09:43.866    [INFO]    Thread[Thread-3,5,main] - syncFunThree after : 21
2018-11-16 23:09:43.916    [INFO]    Thread[Thread-0,5,main] - syncFunThree before : 21
2018-11-16 23:09:43.916    [INFO]    Thread[Thread-0,5,main] - syncFunThree after : 22
2018-11-16 23:09:43.916    [INFO]    Thread[Thread-4,5,main] - syncFunThree before : 22
2018-11-16 23:09:43.916    [INFO]    Thread[Thread-4,5,main] - syncFunThree after : 23
2018-11-16 23:09:43.917    [INFO]    Thread[Thread-1,5,main] - syncFunThree before : 23
2018-11-16 23:09:43.917    [INFO]    Thread[Thread-1,5,main] - syncFunThree after : 24
2018-11-16 23:09:43.917    [INFO]    Thread[Thread-3,5,main] - syncFunThree before : 24
2018-11-16 23:09:43.917    [INFO]    Thread[Thread-3,5,main] - syncFunThree after : 25
2018-11-16 23:09:43.917    [INFO]    Thread[Thread-2,5,main] - syncFunThree before : 25
2018-11-16 23:09:43.917    [INFO]    Thread[Thread-2,5,main] - syncFunThree after : 26

--------------------测试测试wait()和notify()的打印结果如下--------------------
2018-11-16 23:10:09.376    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 before : 1
2018-11-16 23:10:09.380    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 after : 0
2018-11-16 23:10:09.380    [INFO]    Thread[Thread-1,5,main] - sleep beginning.
2018-11-16 23:10:09.380    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 before : 0
2018-11-16 23:10:09.380    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 after : 1
2018-11-16 23:10:12.381    [INFO]    Thread[Thread-1,5,main] - sleep finished.
2018-11-16 23:10:12.381    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 before : 1
2018-11-16 23:10:12.381    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 after : 0
2018-11-16 23:10:12.381    [INFO]    Thread[Thread-1,5,main] - sleep beginning.
2018-11-16 23:10:12.381    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 before : 0
2018-11-16 23:10:12.381    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 after : 1
2018-11-16 23:10:15.382    [INFO]    Thread[Thread-1,5,main] - sleep finished.
2018-11-16 23:10:15.382    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 before : 1
2018-11-16 23:10:15.382    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 after : 0
2018-11-16 23:10:15.382    [INFO]    Thread[Thread-1,5,main] - sleep beginning.
2018-11-16 23:10:15.382    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 before : 0
2018-11-16 23:10:15.382    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 after : 1
2018-11-16 23:10:18.382    [INFO]    Thread[Thread-1,5,main] - sleep finished.
2018-11-16 23:10:18.382    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 before : 1
2018-11-16 23:10:18.382    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 after : 0
2018-11-16 23:10:18.382    [INFO]    Thread[Thread-1,5,main] - sleep beginning.
2018-11-16 23:10:18.382    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 before : 0
2018-11-16 23:10:18.382    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 after : 1
2018-11-16 23:10:21.383    [INFO]    Thread[Thread-1,5,main] - sleep finished.
2018-11-16 23:10:21.383    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 before : 1
2018-11-16 23:10:21.383    [INFO]    Thread[Thread-1,5,main] - syncFunFour2 after : 0
2018-11-16 23:10:21.383    [INFO]    Thread[Thread-1,5,main] - sleep beginning.
2018-11-16 23:10:21.383    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 before : 0
2018-11-16 23:10:21.383    [INFO]    Thread[Thread-0,5,main] - syncFunFour1 after : 1
此处省略...

  二、 ReentrantLock（可重入锁）和 ReentrantReadWriteLock（读写锁）的用法

      ReentrantLock 是一个乐观锁，实现的时候需要手动加锁和释放锁，例如：

　　

import java.util.Random;
import java.util.concurrent.*;

public class MyTest {

    int num = 1; //对num进行逐1累加
    final ReentrantLock lock = new ReentrantLock();

    final class MyWork implements Runnable {
        public void run() {
            while (true) {
                Thread.sleep(new Random().nextInt(2000)+300);
                try {
                    lock.lock();
                    System.out.println(Thread.currentThread().getName()+" : "+ ++num);
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public void execute() {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        executorService.submit(new MyWork());
        executorService.submit(new MyWork());
        executorService.submit(new MyWork());
    }
}

 

  三、常用的java同步组件

//计数类

java.util.concurrent.CountDownLatch
可用于多线程并发等场景。

构造器：CountDownLatch(int count)

主要方法有：await()、getCount()、countDown()
          实现思想是通过unsafe.xxx （Unsafe unsafe = Unsafe.getUnsafe()）

//原子类
java.util.concurrent.atomic.AtomicInteger
封装了原子操作：读写数据。
主要构造器有：AtomicInteger(int initialValue)、AtomicInteger()
主要方法有：get()、set(int newValue)、getAndSet(int newValue)、compareAndSet(int expect, int update)、getAndIncrement()、getAndDecrement()
          实现思想是通过unsafe.xxx （Unsafe unsafe = Unsafe.getUnsafe()）

其他原子类如：AtomicBoolean、AtomicIntegerArray、AtomicLong、AtomicReference<V>等