【JAVA锁机制】

长安归故里♬

已于 2022-06-19 18:01:38 修改

阅读量751

点赞数

文章标签： java

于 2022-04-30 18:23:36 首次发布

本文链接：https://blog.csdn.net/m0_55928120/article/details/124375926

版权

本文介绍了Java中的同步锁机制，包括锁的类型如实例锁、静态锁和锁代码块，以及锁的升级过程。讨论了死锁问题及其四个必要条件，锁重入和让步策略。还提到了线程的控制方法如sleep、yield和join等，并详细讲解了读写锁、并发编程的三大特性、CAS锁以及AQS。最后，文章探讨了Java线程池的四种类型和拒绝策略，以及一些实用的并发工具类如CountDownLatch和Semaphore。

摘要由CSDN通过智能技术生成

同步锁

锁简介
Java三种加锁的方式：

（1）锁住实例：new出来的对象可以并发（new多个对象来获取有锁的方法)


/**
 * 对于存在两个实例锁住的是分别这两个实例（也可以进行多个实例的上锁）
 * 会处于高并发的一个状态
 */
public class SynchronizedDemo2 {
   
    static final SynchronizedDemo2 synchronizedDemo=new SynchronizedDemo2();
    static final SynchronizedDemo2 synchronizedDemo2=new SynchronizedDemo2();
    public static void main(String[] args) {
   
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                synchronizedDemo.generalMethod1();
            }
        }).start();
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                synchronizedDemo2.generalMethod2();
            }
        }).start();
    }
    public synchronized void generalMethod1(){
   
        for (int i = 1; i < 3; i++) {
   
            System.out.println(i+"generalMethod1" );
        }
    }
    public synchronized void generalMethod2(){
   
        for (int i = 1; i < 3; i++) {
   
            System.out.println(i+"generalMethod2" );
        }
    }

}

（2）可以单（new一个实例分别获取方法）


/**
 * 对于只存在一个实例
 * 锁住的只有这个实例
 * 此外不能执行别的实例
 * 当别人调用时首先得获得锁
 */
public class SynchronizedDemo {
   
    static final SynchronizedDemo synchronizedDemo=new SynchronizedDemo();
    public static void main(String[] args) {
   
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                synchronizedDemo.generalMethod1();
            }
        }).start();
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                synchronizedDemo.generalMethod2();
            }
        }).start();
    }
    public synchronized void generalMethod1(){
   
        for (int i = 1; i < 3; i++) {
   
            System.out.println(i+"generalMethod1" );
        }
    }
    public synchronized void generalMethod2(){
   
        for (int i = 1; i < 3; i++) {
   
            System.out.println(i+"generalMethod2" );
        }
    }

}

锁static静态类：class对象（是一种全局锁）锁住内部类：内部块谁获得锁就锁谁


public class SynchronizedDemo3 {
   
    /**
     * 对于静态代码块的上锁
     * 锁住的是当前的SynchronizedDemo3.class 对象
     * 相当于一个全局锁
     * 锁住每一个，让他们串行化
     */
    static final SynchronizedDemo3 synchronizedDemo = new SynchronizedDemo3();
    static final SynchronizedDemo3 synchronizedDemo2 = new SynchronizedDemo3();

    public static void main(String[] args) {
   
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                generalMethod1();
            }
        }).start();
        new Thread(new Runnable() {
   
            @Override
            public void run() {
   
                generalMethod2();
            }
        }).start();
    }

    public synchronized static void generalMethod1() {
   
        for (int i = 1; i < 3; i++) {
   
            System.out.println(i + "generalMethod1");
        }
    }

    public synchronized static void generalMethod2() {
   
        for (int i = 1; i < 3; i++) {
   
            System.out.println(i + "generalMethod2");
        }
    }
}

锁代码块：

         synchronized（this）{
   
                              }//锁实例
         synchronized（Test.class）{
   
                               }//锁类
             
        Object object =new Object();
          synchronized（this）{
   
                               }//锁全局


/**
 *锁住的是代码块中配置的对象
 * 也是比较灵活
 * 1.实例锁 new出来的实例
 * 2.类锁 class
 * 3.全局锁
 */
public class SynchronizedDemo4 {
   
    private static  final Object object=new Object();
    static SynchronizedDemo4 synchronizedDemo=new SynchronizedDemo4();

    public static void main(