参考资料：
http://blog.youkuaiyun.com/zyplus/article/details/6672775
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三种线程整合起来，形成一个共同的类。
所以还得考虑扩展性问题，参考资料中存在解决扩展性的方案。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
