Synchronized内置锁

理论:

　　多个线程之间共享资源就会发成数据上的冲突,我们往往会使用Synchronized关键字来实现锁

　　这个锁要不加在方法上,要么以同步块的形式来使用,它最大作用就是确保多个线程在同一时刻,只能有一个线程处于方法和同步块之中,这样它就保证了线程对变量的可见性和排他性

　　因为这个Synchronized关键字是由Java语言本身为我们提供的,所以习惯将Synchronized关键字称之为内置锁

对象锁:

　　锁的是类的对象实例

类锁:

　　锁的是每个类的Class对象,每个类的Class对象在一个虚拟机中只有一个,所以类锁也只有一个

package org.dance.day1.sync;

import org.dance.tools.SleepTools;

/**
 * 对象锁和类锁
 * @author ZYGisComputer
 */
public class SynClzAndInst {

    /**
     * 使用类锁的线程
     */
    private static class SynClass extends Thread{
        @Override
        public void run() {
            System.out.println("TestClass is running...");
            synClass();
        }
    }

    /**
     * 使用对象锁的线程
     */
    private static class InstanceSyn implements Runnable{
        private SynClzAndInst synClzAndInst;

        public InstanceSyn(SynClzAndInst synClzAndInst) {
            this.synClzAndInst = synClzAndInst;
        }

        @Override
        public void run() {
            System.out.println("TestInstance is running..."+synClzAndInst);
            synClzAndInst.instance();
        }
    }

    /**
     * 使用对象锁的线程
     */
    private static class Instance2Syn implements Runnable{
        private SynClzAndInst synClzAndInst;

        public Instance2Syn(SynClzAndInst synClzAndInst) {
            this.synClzAndInst = synClzAndInst;
        }
        @Override
        public void run() {
            System.out.println("TestInstance2 is running..."+synClzAndInst);
            synClzAndInst.instance2();
        }
    }

    /**
     * 锁对象
     */
    private synchronized void instance(){
        SleepTools.second(3);
        System.out.println("synInstance is going..."+this.toString());
        SleepTools.second(3);
        System.out.println("synInstance ended "+this.toString());
    }

    /**
     * 锁对象
     */
    private synchronized void instance2(){
        SleepTools.second(3);
        System.out.println("synInstance2 is going..."+this.toString());
        SleepTools.second(3);
        System.out.println("synInstance2 ended "+this.toString());
    }

    /**
     * 类锁，实际是锁类的class对象
     */
    private static synchronized void synClass(){
        SleepTools.second(1);
        System.out.println("synClass going...");
        SleepTools.second(1);
        System.out.println("synClass end");
    }

    public static void main(String[] args) {
        // 测试锁两个对象
//        testTwoObject();
        // 测试锁一个对象
//        testOneObject();
        // 测试类锁
        testClass();
        SleepTools.second(1);
    }

    /**
     * 对象锁
     * 因为是锁的两个对象 所以可以同时运行
     */
    public static void testTwoObject(){
        SynClzAndInst synClzAndInst = new SynClzAndInst();
        Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
        SynClzAndInst synClzAndInst2 = new SynClzAndInst();
        Thread t2 = new Thread(new Instance2Syn(synClzAndInst2));
        t1.start();
        t2.start();
    }

    /**
     * 对象锁
     * 因为是锁的同一个对象 所以不可以同时运行
     */
    public static void testOneObject(){
        SynClzAndInst synClzAndInst = new SynClzAndInst();
        Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
        Thread t2 = new Thread(new Instance2Syn(synClzAndInst));
        t1.start();
        t2.start();
    }
    /**
     * 类锁
     * 类锁锁的是虚拟机内存中的唯一一份的class镜像
     */
    public static void testClass(){
        SynClzAndInst synClzAndInst = new SynClzAndInst();
        Thread t1 = new Thread(new InstanceSyn(synClzAndInst));
        t1.start();
        SynClass synClass = new SynClass();
        synClass.start();
    }


}

作者：彼岸舞

时间：2020\09\15

内容关于：并发编程

本文来源于网络，只做技术分享，一概不负任何责任