初探java 对象中wait(),notify(),notifyAll() 和线程中的synchronized

因为学习和兴趣需要，自学一点java的多进程，这两天好像刚刚明白了什么，一查博客，众说纷纭，有些越看越糊涂，所以想结合几篇自己认为还不错的博客，在这算是一个总结了。

首先，我们先谈谈wait(),notify()和notifyAll(),这三个方法呢，是定义在Object中的，而所有对象都继承了Object，所以呢，每个对象都能够调用他们。那么他们都是什么作用呢。

(你可以点开他官方文档，下面只做简单说明)

wait(): 他能阻塞当前线程，直至被notify()或者notifyAll()唤醒，或者是过一段特定的时间，才能再次开始运行.

notify():他能唤醒一个对象监视器（Object monitor）上一个被wait()阻塞的线程，这种唤醒是随机的发生的。

notifyAll():他能唤醒一个对象监视器（Object monitor）上等待的所有被wait()阻塞的线程。

以下内容基本来自于最简实例说明wait、notify、notifyAll的使用方法，我做了很多阉割，所以推荐看下原文。

package testthread;

/**
 * Created by andrew on 14-10-30.
 */
public class NotifyWait {
    private String flag[] = {"true"};

    class NotifyThread extends Thread{
        public NotifyThread(String name)
        {
            super(name);
        }

        public void run()
        {
            try {
                sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (flag) {
                flag[0] = "false";
                flag.notify();
            }
        }
    }

    class WaitThread extends Thread{
        public WaitThread(String name)
        {
            super(name);
        }

        public void run() {
            synchronized (flag) {
                while (flag[0] != "false") {
                    System.out.println(getName() + " begin waiting");
                    long waittime = System.currentTimeMillis();

                    try {
                        flag.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    waittime = System.currentTimeMillis() - waittime;
                    System.out.println("waittime :" + waittime);
                }

                System.out.println(getName() + " end waiting!");
            }
        }
    }

    public static void main(String[] args)
    {
        System.out.println("Main thread run!");

        NotifyWait test = new NotifyWait();

        NotifyThread notifythread = test.new NotifyThread("notify");
        WaitThread waiter0 = test.new WaitThread("waiter0");
        WaitThread waiter1 = test.new WaitThread("waiter1");
        WaitThread waiter2 = test.new WaitThread("waiter2");

        notifythread.start();
        waiter0.start();
        waiter1.start();
        waiter2.start();
    }
}

我们可以看到结果：

Main thread run!
waiter0 begin waiting
waiter1 begin waiting
waiter2 begin waiting
waittime :3000
waiter0 end waiting!

对，很明显，只有一个线程被唤醒，其余两个仍旧在等待。因为在NotifyThread中，我们调用的是notify()，当我们把它换成notifyAll()呢。我们再看看结果:

Main thread run!
waiter0 begin waiting
waiter1 begin waiting
waiter2 begin waiting
waittime :3000
waiter2 end waiting!
waittime :3001
waiter1 end waiting!
waittime :3001
waiter0 end waiting!

这样一看就很清楚的知道差别了。好了，看了上面的程序，有一个细节不知道大家注意到了没。为什么我们synchronized (flag)，而不是synchronized (this)呢？那么他们两者又有什么不同，synchronized又该如何使用呢。

下面内容参考：JAVA线程安全之synchronized关键字的正确用法,

　　 Synchronized关键字总结　　

首先我们先看一段代码

package com;

public class ThreadTest {
	public static void main(String[] args) {
		MyThread m1 = new MyThread(1);
		MyThread m2 = new MyThread(2);
		m1.start();
		m2.start();
	}
}

final class MyThread extends Thread {
	private int val;

	public MyThread(int v) {
		val = v;
	}
	//这种做法其实是非线程安全的
	public synchronized void print1(int v) {
		for (int i = 0; i < 100; i++) {
			System.out.print(v);
		}
	}

	public void print2(int v) {
		//线程安全
		synchronized (MyThread.class) {
			for (int i = 0; i < 100; i++) {
				System.out.print(v);
			}
		}
	}

	public void run() {
		print1(val);
		// print2(val);
	}
}

在调用print1时，结果是12121212121212121212121212121212121212112121212121212121212121212121212121....当然每次结果不一定相同，但是都告诉我们一个道理，这样的同步就没达到我们的目的。

那我们运行print2，又会发生什么呢：11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111112222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222，这不正是我们想要的吗。为什么会这样的？且挺我慢慢道来。

我们先说说synchronized有两种用法：一呢,是同步方法；二呢，就是同步语句块了。

先说说同步方法的使用

public synchronized void methodA()
{
        //code
}

public synchronized static void methodB()
{
        //code
}

这有两个同步方法，唯一不同的是修饰符的不同，第二个是静态，第二个则不是。他们有什么不同呢。首先，我们知道static方法是属于Class,而无static修饰呢，则属于一个具体的实例（Instance）。和之前类似，他们加的锁分别加到不同的对象上。而一个对象只能有一把锁。举例来说吧，我们依然用以上类，因为

<span style="white-space:pre">		</span>MyThread m1 = new MyThread(1);
		MyThread m2 = new MyThread(2);
		m1.start();
		m2.start();

我们创建了两个实例，而方法呢，是非static方法

//这种做法其实是非线程安全的
	public synchronized void print1(int v) {
		for (int i = 0; i < 100; i++) {
			System.out.print(v);
		}
	}

	public void print2(int v) {
		//线程安全
		synchronized (MyThread.class) {
			for (int i = 0; i < 100; i++) {
				System.out.print(v);
			}
		}

所以呢，虽然使用了,synchronized关键字，但是，他只把锁加在实例中，而我们是创建了两个实例，因此，这锁相当于没加。那我们该怎么才能使这两个同步呢。我们可以采用以下方法：

１．

<span style="white-space:pre">	</span>MyThread m1 = new MyThread(1);

        Thread demo1 = new Thread(m1, "abc");
        Thread demo2 = new Thread(m1, "ert");

        demo1.start();
        demo2.start();

２．

    public synchronized static void print1(int v) {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.currentThread().getName());
        }
    }

这样之前的程序也就能正常运行了。

那么，我们要用synchronized语句块该怎么用呢。

在使用同步语句块时，我们得知道，synchronized()括号里加的什么就是对什么进行加锁。如synchronized(this),那就是对当前实例进行加锁.

好了那我们回归上面的问题。我们依然用那个实例进行举例。

假如我们的print2改为我现在改的样子，他还能成功吗？

public void print2(int v) {
        synchronized (this) {
            for (int i = 0; i < 100; i++) {
                System.out.print(v);
            }
        }
    }

答案很明显不能，因为他只是对当前实例进行加锁，我们的程序运行的是两个实例，所以根本就没有用。

所以，我们在编程中使用

public void print2(int v) {
        synchronized (this.class) {
            for (int i = 0; i < 100; i++) {
                System.out.print(v);
            }
        }
    }

或者是如我们最开始的那个类一样：

synchronized (flag) {
                while (flag[0] != "false") {
                    System.out.println(getName() + " begin waiting");
                    long waittime = System.currentTimeMillis();

                    try {
                        flag.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    waittime = System.currentTimeMillis() - waittime;
                    System.out.println("waittime :" + waittime);
                }

                System.out.println(getName() + " end waiting!");
            }

对synchronized(static 的 临界变量);如此以来，我们能保证所加的所是加在整个Class中，而不是单一的实例里。

文章可能有错，欢迎大家的批评改正。