java concurrent 线程通信_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 = newReentranLock();

lock.lock();

需要同步的代码；

lock.unlock();

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

ReentranReadWriteLock lock = newReentranReadWriteLock();

lock.readLock().lock();

需要读锁同步的代码；

lock.readLock().unlock();

lock.writeLock().lock();

需要写锁同步的代码；

lock.writeLock().unlock();

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

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

在获得锁而执行的线程执行时，执行到某处时需要申请同一把锁的其他线程先执行，此时就需要让出同步锁以及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：

packagejoinTest1;public class MyThread extendsThread {

@Overridepublic voidrun() {try{int secondValue = (int) (Math.random() * 10000);

System.out.println(secondValue);

Thread.sleep(secondValue);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

}

packagejoinTest1;public classTest {public static voidmain(String[] args) {

MyThread threadTest= newMyThread();

threadTest.start();//Thread.sleep(?)

System.out.println("我想当threadTest对象执行完毕后我再执行");

System.out.println("但上面代码中的sleep()中的值应该写多少呢？");

System.out.println("答案是：根据不能确定:)");

}

}

运行结果：

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

packagejoinTest2;public class MyThread extendsThread {

@Overridepublic voidrun() {try{int secondValue = (int) (Math.random() * 10000);

System.out.println(secondValue);

Thread.sleep(secondValue);

}catch(InterruptedException e) {//TODO Auto-generated catch block

e.printStackTrace();

}

}

}

packagejoinTest2;public classTest {public static voidmain(String[] args) {try{

MyThread threadTest= newMyThread();

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