Java并发之线程间的同步协作与通信协作

1，Monitor监视器与syncrhoized实现原理

1.1：Monitor

Monitor是一个同步工具，相当于操作系统中的互斥量（mutex），即值为1的信号量。

它内置与每一个Object对象中，相当于一个许可证。拿到许可证即可以进行操作，没有拿到则需要阻塞等待。

1.2：syncrhoized实现原理

syncrhoized又叫做内置锁，为什么呢？因为使用syncrhoized加锁的同步代码块在字节码引擎中执行时，其实是通过锁对象的monitor的取用与释放来实现的。由上面我们直到Monitor是内置于任何一个对象中的，syncrhoized利用monitor来实现加锁解锁，故syncrhoized又叫做内置锁。

现在我们知道为什么用syncrhoized(lock)来加锁时，锁对象可以是任意对象了：

1：syncrhoized(lock)加锁时，用到的其实只是lock对象内置的monitor而已；

2：一个对象的monitor是唯一的，相当于一个唯一的许可证。拿到许可证的线程才可以执行，执行完后释放对象的monitor才可以被其他线程获取。

我们来讲解一下syncrhoized加锁的同步块的执行过程：

现在假设有代码块：

　　　　　　syncrhoized（Object lock）{

同步代码...;

}

它在字节码文件中被编译为：

　　　　　　monitorenter;//获取monitor许可证，进入同步块

同步代码...

monitorexit;//离开同步块后，释放monitor许可证

2，线程间的同步协作与通信协作

2.1：线程的状态以及变化图

Java中线程中状态可分为五种：New（新建状态），Runnable（就绪状态），Running（运行状态），Blocked（阻塞状态），Dead（死亡状态）。

　　New：新建状态，当线程创建完成时为新建状态，即new Thread(...)，还没有调用start方法时，线程处于新建状态。

　　Runnable：就绪状态，当调用线程的的start方法后，线程进入就绪状态，等待CPU资源。处于就绪状态的线程由Java运行时系统的线程调度程序(thread scheduler)来调度。

　　Running：运行状态，就绪状态的线程获取到CPU执行权以后进入运行状态，开始执行run方法。

　　Blocked：阻塞状态，线程没有执行完，由于某种原因（如，I/O操作等）让出CPU执行权，自身进入阻塞状态。

　　Dead：死亡状态，线程执行完成或者执行过程中出现异常，线程就会进入死亡状态。

2.2 线程间的同步协作

由syncrhoized同步锁、ReentrantLock（可重入锁）、ReadWriteLock（读写锁）等待同步机制，实现线程之间的同步。

说明：

1）syncrhoized也是可重入锁，基本用法

syncrhoized（Object lock）{
     需要同步的代码...;
 }

2）ReentrantLock类（不是关键字）可以实现syncrhoized同样的效果并且有扩展功能

Lock lock = new ReentranLock();
lock.lock();
 　 需要同步的代码；
lock.unlock();

3）ReentrantReadWriteLock类有两个锁，读相关的锁（也叫共享锁），写相关的锁（也叫排他锁）。

ReentranReadWriteLock lock = new ReentranReadWriteLock();

lock.readLock().lock();
 　 需要读锁同步的代码；
lock.readLock().unlock();

lock.writeLock().lock();
 　 需要写锁同步的代码；
lock.writeLock().unlock();

线程获得锁则进入就绪态，等待CPU调度进入运行态；

线程申请被占用的锁，则进入阻塞态，让出CPU使用权。直到获得该锁后，重新进入就绪态，等待CPU调度进入运行态。

2.3 线程间的通信协作

在获得锁而执行的线程执行时，执行到某处时需要申请同一把锁的其他线程先执行，此时就需要让出同步锁以及CPU（进入阻塞态），让其他线程先获取同步锁以及CPU而执行。直到其他线程执行完并释放同步锁后通知它唤醒（就绪态），才接着申请同步锁以及CPU而继续执行下去（运行态）。

 这个线程之间 让出资源、挂起、唤醒 就是通过线程的通信来实现的。

两种方式：

1）syncrhoized加锁的线程的wait()/notify()/notifyAll()

2）ReentrantLock类加锁的线程的Condition类调用await()/signal()/signalAll()

Object类中的wait()/notify()/notifyAll()方法依次与Condition类中的await()/signal()/signalAll()一一对应

2.4  线程自身的动作

1） 线程自身可以通过调用 sleep() 方法进入阻塞态，暂时让出CPU资源（但是不释放锁），休眠时间过后自动恢复就绪态等待CPU调度执行；

2）线程自身可以通过调用 yield() 方法由运行态变为就绪态；这个过程称为“让步”，即正在运行的线程让出CPU给就绪态中的线程先执行一下，自己则回到就绪态中等待CPU再次调度自己执行；

3）线程可以在自身执行过程中，通过其他线程对象.join() 方法把已经启动的其他线程先执行完 ，再继续执行自身的余下操作。可以通过这个方法来实现线程之间顺序执行。

join()方法解释：

为什么要使用join：

package joinTest1;

public class MyThread extends Thread {

    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

package joinTest1;

public class Test {

    public static void main(String[] args) {

        MyThread threadTest = new MyThread();
        threadTest.start();

        // Thread.sleep(?)
        System.out.println("我想当threadTest对象执行完毕后我再执行");
        System.out.println("但上面代码中的sleep()中的值应该写多少呢？");
        System.out.println("答案是：根据不能确定:)");
    }

}

运行结果：

问题就是，我们当前线程想在某个线程（其实就是当前线程的子线程）执行完成后执行，要等多长时间，其实还有一个问题是，join内部是wait实现的会释放锁，而sleep不会释放锁。

package joinTest2;

public class MyThread extends Thread {

    @Override
    public void run() {
        try {
            int secondValue = (int) (Math.random() * 10000);
            System.out.println(secondValue);
            Thread.sleep(secondValue);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

package joinTest2;

public class Test {

    public static void main(String[] args) {
        try {
            MyThread threadTest = new MyThread();
            threadTest.start(); //启动子线程
            threadTest.join();  //当时间片又来到当前线程（父线程）时，运行了子线程类的join方法，把当前线程（父线程）无限期阻塞，直到子线程销毁再执行父线程余下的代码。

            System.out.println("我想当threadTest对象执行完毕后我再执行，我做到了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

运行结果

方法join具有使线程排队运行的作用。

《Java多线程编程核心技术》

http://www.cnblogs.com/ygj0930/p/6561589.html

https://www.cnblogs.com/ygj0930/p/6561667.html