Java线程同步详解

线程的两种实现方式和区别就不说了，大家可以看看教程...

1.线程加入：

      join()方法，等待其他线程终止。在当前线程中调用另一个线程的t.join()方法，则当前线程转入阻塞状态，直到另一个线程t运行结束，当前线程再由阻塞转为就绪状态。

看下面的事例代码：

/**
 * Created by huogd 2016年5月16日 下午5:50:28
 */
public class Thread1 extends Thread {
    private String name;
    private int count = 5;

    public Thread1(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行  count= " + count--);
            try {
                sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread1 mTh1 = new Thread1("A");
        Thread1 mTh2 = new Thread1("B");

        System.out.println(mTh1.getState().name());
        System.out.println(mTh2.getState().name());

        mTh1.start();
        mTh2.start();

        mTh1.join(); // 只有mTh1执行完，当前线程，也就是main thread 的for循环才会执行。所以可以使用该方法设置线程的执行顺序。
        for (int i = 0; i < 5; i++) {
            System.out.println("main thread " + i);
        }
    }
}

      在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

2.线程让步：

      Thread.yield() 方法，暂停当前正在执行的线程对象，把执行机会让给相同或者更高优先级的线程。yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

例如下面的代码所示：

public class Thread1 extends Thread {
    private String name;
    private int count = 5;

    public Thread1(String name) {
        this.name = name;
    }

    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(name + "运行  count= " + count--);
            try {
                sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread1 mTh1 = new Thread1("A");
        Thread1 mTh2 = new Thread1("B");

        for (int i = 0; i < 5; i++) {
            System.out.println("main thread " + i);
            if(i==3){
              Thread.yield();//使当前线程也就是main暂停，并执行其他线程，但是有时候效果不明显，也就是不起作用
                     //所以依然是main线程的for循环先执行完，然后执行下面的两个线程
            }
        }
        
        mTh1.start();
        mTh2.start();
    }
}

        sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
        sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU  的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程

       另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让较低优先级的线程获得 CPU 占有权。

------------------------------------------------------------华丽分割线-------------------------------------------------------------------------------

3.线程同步(重点，如何保证线程同步执行，而不导致线程死锁阻塞)

在以下情况下，持有锁的线程会释放锁：

1. 执行完同步代码块。
2. 在执行同步代码块的过程中，遇到异常而导致线程终止。
3. 在执行同步代码块的过程中，执行了锁所属对象的wait()方法，这个线程会释放锁，进行对象的等待池。

      wait()/notify()/notifyAll()需要在同步块或者同步方法中调用，否则会抛出InvalidMonitorStateException。也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用wait()/notify()/notifyAll()时，会抛出异常。Obj.wait()与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。

      从功能上来说，当线程执行对象的wait()时，会把当前的锁释放，然后让出CPU，进入等待状态。当执行notify方法时（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放），会唤醒一个处于等待该 对象锁 的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。

      从这里可以看出，notify执行后，并不立即释放锁，而是要等到执行完临界区中代码后，再释放。故，在实际编程中，我们应该尽量在线程调用notify后，立即退出临界区。即不要在notify/notifyAll()后面再写一些耗时的代码。比如下面代码 1处注释是不可取的的。

      JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。wait和notify是线程等待和唤醒线程，但是是锁对象调用这两个方法，并且调用某一个对象的wait方法或者notify方法必须在该对象所锁住的代码块内，否则会跑出会抛出java.lang.IllegalMonitorStateException异常，也就是状态监视器异常。wait会释放锁，notify仅仅只是通知，不释放锁。

看下面经典题：

建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。

public class MyThreadPrinter2 implements Runnable {

    private String name;
    private Object prev;
    private Object self;

    private MyThreadPrinter2(String name, Object prev, Object self) {
        this.name = name;
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        int count = 10;
        while (count > 0) {
            synchronized (prev) {
                synchronized (self) {
                    System.out.print(name);
                    if ("C".equals(name)) {
                        System.out.println();
                    }
                    count--;

                    self.notify();

                    // 1这里是不可取的
                    /*if ("C".equals(name)) {
                        for (int i = 0; i < 1000; i++) {
                            System.out.println("线程C还在执行" + i);
                            try {
                                Thread.sleep(i);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }*/
                }
                try {
                    prev.wait();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

        }
    }

    public static void main(String[] args) throws Exception {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        MyThreadPrinter2 pa = new MyThreadPrinter2("A", c, a);
        MyThreadPrinter2 pb = new MyThreadPrinter2("B", a, b);
        MyThreadPrinter2 pc = new MyThreadPrinter2("C", b, c);

        new Thread(pa).start();
        Thread.sleep(100); // 确保按顺序A、B、C执行
        new Thread(pb).start();
        Thread.sleep(100);
        new Thread(pc).start();
        Thread.sleep(100);
    }
}

      先来解释一下其整体思路，从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循环执行三个线程。为了控制线程执行的顺序，那么就必须要确定唤醒、等待的顺序，所以每一个线程必须同时持有两个对象锁，才能继续执行。一个对象锁是prev，就是前一个线程所持有的对象锁。还有一个就是自身对象锁。主要的思想就是，为了控制执行的顺序，必须要先持有prev锁，也就前一个线程要释放自身对象锁，再去申请自身对象锁，两者兼备时打印，之后首先调用self.notify()释放自身对象锁，唤醒下一个等待线程，再调用prev.wait()释放prev对象锁，终止当前线程，等待循环结束后再次被唤醒。运行上述代码，可以发现三个线程循环打印ABC，共10次。程序运行的主要过程就是A线程最先运行，持有C,A对象锁，后释放A,C锁，唤醒B。线程B等待A锁，再申请B锁，后打印B，再释放B，A锁，唤醒C，线程C等待B锁，再申请C锁，后打印C，再释放C,B锁，唤醒A。看起来似乎没什么问题，但如果你仔细想一下，就会发现有问题，就是初始条件，三个线程按照A,B,C的顺序来启动，按照前面的思考，A唤醒B，B唤醒C，C再唤醒A。但是这种假设依赖于JVM中线程调度、执行的顺序。注：纯粹拿来主义

4.线程唤醒
      Object类中的notify()方法，唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。 直到当前的线程放弃此对象上的锁定，才能继续执行被唤醒的线程。被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争；例如，唤醒的线程在作为锁定此对象的下一个线程方面没有可靠的特权或劣势。类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。 
 

5.线程同步 
1、synchronized关键字的作用域有二种：     
      1>是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；     
      2>是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 
 2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 
 3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了synchronized f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。

大家可以加qq群，有问题一起讨论，学习：365133566