多线程使用之-----synchronized／wait／not

参考文献： java synchronized详解

• synchronized 修饰方法

public synchronized void accessVal(int newVal);  

synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。 在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized ，以控制其对类的静态成员变量的访问。

• 修饰代码块

 synchronized (object) {
            waitThread.start();
            try {
                System.out.print("主线程等待\n");
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

获得的锁是传入的 类的实例中的锁
有如下一个例子：

public class Main {

   private static  dog  object = new dog();

    public static void main(String[] args) {

        System.out.print("主线程运行\n");
        WaitThread waitThread = new WaitThread();

         //waitThread.start();  

        synchronized (object) {
            waitThread.start();  //注意此处放的地方
            try {
                System.out.print("主线程等待\n");
                object.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.print("主线程结束\n");
    }

    static class WaitThread extends  Thread {
        @Override
        public void run() {
            try {
                synchronized (object) {
                    Thread.sleep(3000);
                    System.out.print("主线程唤起\n");
                    object.notifyAll();
                }
            } catch (Exception e) {

            }
        }
    }
}

结果：

主线程运行
主线程等待
（sleep3秒）
主线程唤起
主线程结束
Process finished with exit code 0

请注意上述例子中的waitThread.start(); 执行的地方，是放在了synchronized(Objedt) {} 块中；如果将此代码放到它的外边也就是注释掉的地方，就会有问题：

主线程运行
（sleep3秒）
主线程唤起
主线程等待

因为在执行 run方法时已经持有了object 的锁，主线程中的synchronized 的实例object锁 已经被持有了，所以不能执行，等子线程中的锁释放之后主线程才可以执行

注意点：wait() , notify() ,notifyAll() ,必须放在synchronized block 中，否则会抛异常。也就是说它们都是线程不安全的。

在做测试的时候每次wait()之后的nofity()时线程在争夺同一把锁的时候是随机的，谁抢到就给谁。
notifyAll() 让我想起了在做驱动时的一种惊群效应，一旦锁被释放了，所有的wait线程被唤醒。

对于对象obj来说：
obj.wait()：该方法的调用，使得调用该方法的执行线程（T1）放弃obj的对象锁并阻塞，直到别的线程调用了obj的notifyAll方法、或者别的线程调用了obj的notify方法且JVM选择唤醒（T1），被唤醒的线程（T1）依旧阻塞在wait方法中，与其它的线程一起争夺obj的对象锁，直到它再次获得了obj的对象锁之后，才能从wait方法中返回。（除了notify方法，wait还有带有时间参数的版本，在等待了超过所设时间之后，T1线程一样会被唤醒，进入到争夺obj对象锁的行列；另外中断可以直接跳出wait方法）

obj.notify()：该方法的调用，会从所有正在等待obj对象锁的线程中，唤醒其中的一个（选择算法依赖于不同实现），被唤醒的线程此时加入到了obj对象锁的争夺之中，然而该notify方法的执行线程此时并未释放obj的对象锁，而是离开synchronized代码块时释放。因此在notify方法之后，synchronized代码块结束之前，所有其他被唤醒的，等待obj对象锁的线程依旧被阻塞。

obj.notifyAll()：与notify的区别是，该方法会唤醒所有正在等待obj对象锁的线程。（不过同一时刻，也只有一个线程可以拥有obj的对象锁）

另Thread.join() : 阻塞当前调用join函数时所在的线程，直到接受线程执行完毕之后再继续，有点类似wait，但是这个是Thread调用，阻塞当前调用线程的，并直到执行的线程执行完毕之后才不阻塞当前线程

Thread.yeid() :使该函数的线程让出CPU固定的时间。主动让出线程的执行权给其他线程。因为让的的线程有可能被线程调度程序再次选中，所以有可能没有效果（亲测确实如此），谨慎使用。

public static void main(String[] args) {


        Mrunable1 thread1 = new Mrunable1("A\n");
        Mrunable1 thread2 = new Mrunable1("B\n");

        thread1.start();
        thread2.start();

    }

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

        @Override
        public synchronized void run() {
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.print(Thread.currentThread().getName());

                Thread.yield();
            }
        }

这是其中的部分截图