juc学习备忘录--线程八锁

package com.wyz.juc;

/**
 * 线程八锁
 * 题目：判断打印的“one" or ”two“?
 *      1. 两个普通同步方法，两个线程，标准打印，打印？  //One Two
 *      2.新增Tread.sleep()给getOne 打印？ //One Two
 *      3.新增普通的getThree 打印？ //Three One Two
 *      4.两个普通的同步方法，两个NumberDemo对象，打印？ //Two One
 *      5.修改 getOne()为静态同步方法 ，一个NumberDemo对象 //TWo One
 *      6.修改 两个为静态同步方法 ，一个NumberDemo对象 //One TWo
 *      7.一个静态同步方法，一个非静态同步方法，两个NumberDemo对象 //Two One
 *      8.两个静态对象，两个同步方法？ //one Two
 *
 *     线程八锁的关键：
 *     ①.非静态方法的锁默认为this,静态方法的锁为对应的class实例
 *     ②某一时刻内，只能有一个线程持有锁，无论几个方法
 *
 *
 * •一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用
 * 其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻
 * 内，只能有唯一一个线程去访问这些synchronized方法
 * • 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法
 * • 加个普通方法后发现和同步锁无关
 * • 换成两个对象后，不是同一把锁了，情况立刻变化。
 * • 都换成静态同步方法后，情况又变化
 * • 所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实
 * 例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获
 * 取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实
 * 例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非
 * 静态同步方法释放锁就可以获取他们自己的锁。
 * • 所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对
 * 象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个
 * 静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取
 * 锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同
 * 步方法之间，只要它们同一个类的实例对象
 * @author WangChong
 */
public class TestThread8Monitor {
    public static void main(String[] args) {
        NumberDemo numberDemo = new NumberDemo();
        NumberDemo numberDemo2 = new NumberDemo();

        new Thread(new Runnable() {
            @Override
            public void run() {
                numberDemo.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
//                numberDemo.getTwo();
                numberDemo2.getTwo();
            }
        }).start();

//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                numberDemo.getThree();
//            }
//        }).start();
    }
}

class NumberDemo{
    public static synchronized void getOne(){//持有锁为NumberDemo.class的实例
        try {
            Thread.sleep(3000);
            System.out.println("One");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public  synchronized void getTwo(){//持有锁为 当前实例对象 （this）
        System.out.println("Two");
    }

    public  void getThree(){
        System.out.println("Three");
    }
}