java锁机制

synchronize:并发编程中的元老级角色，jdk1.6之前的由于上锁的操作的性能开销太大，所以这种锁又叫做重量级锁，之后jdk1.6以后引入偏 向锁和轻量级锁对其进行了一系列的优化。

synchronize可以锁的对象包括：成员方法，静态方法，代码块（类对象，调用该方法的对象this，对象）

锁机制就是一个标志位，用0或者1表示对象是否被线程使用映射到锁机制就是是否上了锁。

sychronized锁在成员方法上，相当于锁在this上面，锁在静态方法上相当于所在.class文件上。

synchronized关键字的使用，并且注意锁静态方法与锁成员方法的区别

package com.ydlclass.lock;

public class SynchronizedLock {
    public static final Object MONITOR = new Object();//只要这个对象，每个线程都能访问到，由于是静态的，使用这种方式代替sychronized（.class）
    
    public synchronized void say1() throws InterruptedException {
        Thread.sleep(200);
        System.out.println("say1");
        //如果想锁this,可以使用这种方式
        //在成员方法中sychronized(this){}
    }
    public static  synchronized void say2() throws InterruptedException {//加上synchronized,线程回一次调用这个方法；
        //如果去掉，那么可能回一次直接输出，并且可能是乱序的
        Thread.sleep(200);
        System.out.println("say2");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 50; i++) {
            new Thread(()->{
                try {
                    //new SynchronizedLock().say1();//say1不会被锁住，原因不同的对象，所以不是一把锁，所以不能
                    say2();
                    System.out.println("_____" + Math.random() + "______");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();

        }
//        for (int i = 0; i < 50; i++) {
//            new Thread(()->{
//                synchronized (MONITOR) {
//                    try {
//                        Thread.sleep(200);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
//                    System.out.println(2);
//                    System.out.println("___" + Math.random() + "___");
//                }
//            }).start();
        }
    }
}