java同步技术-wait, notify, synchronized



参考资料：

/content/2048536.html

http://www.jb51.net/article/36553.htm

在JAVA中，是没有类似于PV操作、进程互斥等相关的方法的。JAVA的进程同步是通过synchronized()来实现的，需要说明的是，JAVA的synchronized()方法类似于操作系统概念中的互斥内存块，在JAVA中的Object类型中，都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。明白这个原理，就能理解为什么synchronized(this)与synchronized(staticXXX)的区别了，synchronized就是针对内存区块申请内存锁，this关键字代表类的一个对象，所以其内存锁是针对相同对象的互斥操作，而static成员属于类专有，其内存空间为该类所有成员共有，这就导致synchronized()对static成员加锁，相当于对类加锁，也就是在该类的所有成员间实现互斥，在同一时间只有一个线程可访问该类的实例。如果只是简单的想要实现在JAVA中的线程互斥，明白这些基本就已经够了。但如果需要在线程间相互唤醒的话就需要借助Object.wait(),Object.nofity()了。

Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
根据上述的原理，简单书写下列的示例代码，模拟一个消费者和一个生产者，生产者生成字符串，而消费者消费字符串。在生产者生产出字符串之前，消费者阻塞.

importjava.util.*;

publicclass testlinkedlist{

public static void main(String args[])

{

linkedlist lk = new linkedlist();

consumer c = new consumer(lk);

producer p = new producer(lk);

new Thread(c).start();

new Thread(p).start();

}

}

classlinkedlist{

private List <String> taskqueue;

private int i;

public linkedlist()

{

taskqueue = newLinkedList<String>();

i = 0;

}

public void addStr(){

wait(40);

System.out.println("beforeaddstr");

synchronized(taskqueue){

taskqueue.add("abc"+i);

i++;

taskqueue.notify();

}

System.out.println("afteraddstr");

}

public void remStr(){

System.out.println("beforeremstr");

synchronized(taskqueue){

while(taskqueue.isEmpty())

{

try{

taskqueue.wait(50000);

}catch(Exceptione){e.printStackTrace();}

}

String getstr =taskqueue.remove(0);

System.out.println(getstr);

}

System.out.println("after remstr");

}

public void wait(int delay){

try{

Thread.sleep(delay);

}catch(Exception e){

e.printStackTrace();

}

}

}

classconsumer implements Runnable{

private linkedlist source;

public consumer(linkedlist source){

this.source = source;

}

public void run(){

source.remStr();

}

}

classproducer implements Runnable{

private linkedlist source;

public producer(linkedlist source){

this.source = source;

}

public void run(){

source.addStr();

}

}

单单在概念上理解清楚了还不够，需要在实际的例子中进行测试才能更好的理解。对Object.wait()，Object.notify()的应用最经典的例子，应该是三线程打印ABC的问题了吧，这是一道比较经典的面试题，题目要求如下：

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。这个问题用Object的wait()，notify()就可以很方便的解决。代码如下：

上面的这个问题挺有趣的，值得好好地去思考。下面是我的答案：

classthreada implements Runnable{

private Object a; private Object b;
privateObject c;

public threada(Object a, Object b, Objectc){

this.a = a; this.b = b;
this.c= c;

}

public void run(){

for(int i=0; i<10; i++){

print();

try{

Thread.sleep(1);

}catch(Exception e){

e.printStackTrace();

}

synchronized(b){

b.notify();

}

synchronized(a){

try{

a.wait();

}catch(Exceptione){e.printStackTrace();}

}

}

}

static void print(){

System.out.print("A");

}

}

classthreadb implements Runnable{

private Object a; private Object b;
privateObject c;

public threadb(Object a, Object b,Object c){

this.a = a; this.b = b;
this.c= c;

}

public void run(){

for(int i=0; i<10; i++){

synchronized(b){

try{

b.wait();

//System.out.println("b.wait()");

}catch(Exceptione){e.printStackTrace();}

}

print();

synchronized(c){

c.notify();

}

}

}

static void print(){

System.out.print("B");

}

}

classthreadc implements Runnable{

private Object a; private Object b;
privateObject c;

public threadc(Object a, Object b, Objectc){

this.a = a; this.b = b;
this.c= c;

}

public void run(){

for(int i=0; i<10; i++){

synchronized(c){

try{

c.wait();

}catch(Exceptione){;}

}

print();

synchronized(a){

a.notify();

}

}

}

static void print(){

System.out.print("C\n");

}

}

publicclass test{

public static void main(String args[]){

Object a = new Object();

Object b = new Object();

Object c = new Object();

new Thread(newthreada(a,b,c)).start();

new Thread(newthreadb(a,b,c)).start();

new Thread(newthreadc(a,b,c)).start();

}

}

此处值得注意的是红色部分的代码，如果没有红色部分的代码，整个程序会停留在打印出第一个A的地方；

之所以产生这种效果的原因猜想：cpu在调度程序时，首先调度threada，然后一并将notify()语句执行了；造成的结果就是threadb中的wait()真正执行时错过了前面的notify()；

而红色部分的代码，主要目的就是让threada中的notify()停顿下；

待改进：

上述的代码存在问题，即可扩展性不强；如果我们换成4,5个线程的情况呢？那是不是要重新增加再写两个class；所以应该想办法将threada,threadb和threadc三种线程整合起来，形成一个共同的类。

所以还得考虑扩展性问题，参考资料中存在解决扩展性的方案。