浅谈一下Java锁机制

        在学习锁之前,我们先一起来了解几个关于锁的概念。了解之后,再进一步去学习锁的知识。

公平锁和非公平锁

        公平锁:意思就是各个线程之间是公平的,不存在相互竞争的情况,多个线程之间按照申请锁的顺序来获取锁。

        非公平锁:是指多个线程之间获取锁的顺序并不是按照申请的所的顺序,而是通过相互之间的竞争来获取锁,谁抢到了谁就拥有这把锁。

可重入锁

       允许同一个线程重复获取同一个锁,这种能被同一个线程反复获取的锁,就叫做可重入锁。

乐观锁和悲观锁

        乐观锁:顾名思义,代表他这把锁十分乐观。他总是觉得线程中的资源和数据不会被修改。所以他在读取的时候是不会加锁的,但是在乐观锁再进行写入操作的时候会判断数据是否被修改过。

        悲观锁:与乐观锁截然不同,他具有严重的受害心理,他具有强烈的独占和排他性质。他总是认为资源和数据会被别人修改,所以他在持有数据的时候会把资源和数据都锁上,这样其他线程想要请求这个资源就会阻塞,直到悲观锁释放资源为止。

了解完这几个概念之后,我们一起来看看Java中的锁:

Synchronized

        Synchronized,就是一个:非公平,悲观,可重入的锁。

Synchronized关键字的用法

        1.修饰实例方法:默认为this当前方法调用对象;

        2.修饰静态方法:默认为Class对象;

        3.修饰代码块:是某个指定的Java对象;

Synchronized修饰实例方法

        使用this当前对象作锁,锁定该方法,只有获取到this锁,才可以访问当前方法。

        在并发过程中,可以有多个线程同时请求该方法,但是只有一个方法可以获取到锁,执行该方法。

        对于不同的线程,他们所持有的对象,必须是相同的。

有以下两种方法使用Synchronized修饰实例方法,其作用和意义都是相同的。

public class DoSth {
    // 实例方法
    public synchronized void doSth1() {
        // 获取this锁,执行该方法
    }
    
    // 实例方法
    public void doSth2() {
        synchronized(this) {
           // 获取this锁,执行该代码块
        }
    }
}
public static void main(String[] args) {
    // 实例化一个对象
    DoSth do = new DoSth();
	
    // 创建不同的线程1
    Thread t1 = new Thread() {
        public void run() {
            // 使用相同的对象访问synchronized方法
            do.doSth1();
        }
    };
	
    // 创建不同的线程2
    Thread t2 = new Thread() {
        public void run() {
            // 使用相同的对象访问synchronized方法
            do.doSth1();
        }
    };
    
    // 启动线程
    t1.start();
    t2.start();
}

 Synchronized修饰静态方法

        使用当前对象的class对象作为锁,锁定该方法,只有获取到了class锁,才能执行该方法;

        多个线程所持有的对象可以不同,但其class类型必须相同;

public class DoSth {
    // 静态方法
    public synchronized static void doSth1() {
        // 获取当前对象的Class对象锁,执行该方法
    }
    
    // 实例方法
    public static void doSth2() {
        synchronized(this.getClass()) {
        	// 获取当前对象的Class对象锁,执行该代码块
        }
    }
}
public static void main(String[] args) {
    // 创建不同的对象(相同类型)
    DoSth do1 = new DoSth();
    DoSth do2 = new DoSth();

    // 创建不同线程1
    Thread thread01 = new Thread() {
        public void run() {
            // 使用不同的对象访问synchronized方法
            do1.doSth2();
        }
    };

    // 创建不同线程2
    Thread thread02 = new Thread() {
        public void run() {
            // 使用不同的对象访问synchronized方法
            do2.doSth2();
        }
    };

    // 启动线程
    thread01.start();
    thread02.start();
}

 Synchronized修饰代码块

        使用自定义对象作为锁;

synchronized(自定义对象) {
   
}

 Synchronized的底层实现

        Synchronized的底层是由Monitor监视器所实现的,Synchronized代码块是通过一对 monitorenter / monitorexit 指令实现的。线程通过monitorenter指令来尝试获取monitor的所有权,当monitor被占用时就会处于锁定状态。

线程获取monitor的过程

        1.如果monitor的进入数为0,则当前线程可以进入monitor,然后设置进入数为1,代表当前线程为monitor的持有者,即持有锁;

        2.如果当前线程已经持有了monitor,只是重新进入,则monitor的进入数会+1;

        3.如果在当前线程之前,已经有其他线程持有了monitor,则当前线程就会进入阻塞状态;直到monitor的进入数为0的时候,会再次尝试获取monitor;

Synchronized的锁升级机制

        锁升级的针对Synchronized的一种机制,是对于Synchronized的一种优化,JVM会检测不同的情况,自动切换到适应的锁实现,即为锁的升级与降级。

        在JVM中实现了三种类型的锁:偏向锁、轻量级锁、重量级锁

偏向锁

        偏向锁适用于单线程的情况,如果发现有多个线程执行就会自动升级为轻量级锁;

轻量级锁

        轻量级锁适用于多线程串行执行的情况,即多个线程按顺序执行,如果发现多个线程并行执行了就会自动升级为重量级锁;

重量级锁

        重量级锁适用于多线程并行执行。

下图为Synchronized锁升级的原理:

浅谈一下Java锁机制_第1张图片

 

ReentartLock

        ReentartLock,就是默认非公平但可实现公平的,悲观,可重入的锁。

        ReentartLock与Synchronized不同的是:在Synchronized中,线程只要获取不到锁,就会进入阻塞状态,一直等待,没有额外的尝试机制;而ReentartLock可以在获取失败后,可以尝试获取锁。

ReentartLock内部结构

        ReentartLock内部共有三个类:Sync、NotfairSync、FairSync

        NotfairSync类继承了Sync类:表示不公平策略获取锁,在获取锁的时候,不会按照公平的原则进行,不会让等待时间最久的线程获得锁,按照抢占机制来争夺锁;

        FairSync类继承Sync类:表示公平策略获取锁,在获取锁的时候,按照公平的原则进行,当资源处于空闲状态时,他总会判断是否有等待时间更长的线程,如果有则将当前线程加入到等待队列的尾部,实现了公平获取原则。

        ReentartLock构造方法:默认采用非公平锁。

public ReentrantLock() {
    // 默认非公平策略
    sync = new NonfairSync();
}

        也可以通过传递参数确定采用公平策略或者是非公平策略,参数为 true表示公平策略,否则,采用非公平策略。

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

 Synchronized和ReentartLock的对比

Synchronized ReentartLock
是一个关键字,依赖于JVM的底层实现 是一个类,依赖于JDK API
实现机制 Monitor监视器 AQS(AbstractQueueSynchronizer)
锁的获取 抢占机制 可以通过tryLock()尝试获取锁,更加灵活
锁的释放 自动释放 必须手动释放锁
锁的类型 非公平锁 公平锁和非公平锁
可重入性 可重入 可重入

补充:死锁

        死锁是指多个线程之间,都需要获取对方所持有的锁或者资源,所导致的无线等待状态。

例如:

package com.zwd.demo;

public class DeadLock {
	private static Object lockA = new Object();
	private static Object lockB = new Object();
	
	public void add() throws InterruptedException {
		synchronized (lockA) { // 获得lockA的锁
			Thread.sleep(100); // 线程休眠
			synchronized (lockB) { // 获得lockB的锁
				System.out.println("执行add()");
			} // 释放lockB的锁
		} // 释放lockA的锁
	}

	public void dec() throws InterruptedException {
		synchronized (lockB) { // 获得lockB的锁
			Thread.sleep(100); // 线程休眠
			synchronized (lockA) { // 获得lockA的锁
				System.out.println("执行dec()");
			} // 释放lockA的锁
		} // 释放lockB的锁
	}
}

对于上述代码而言:

        当线程1和线程2分别执行add()和dec()时: 

        线程1:进入add(),获得lockA;        线程2:进入dec(),获得lockB;

        线程1:休眠100毫秒,准备获取lockB,失败,等待中...

        线程2:休眠100毫秒,准备获取lockA,失败,等待中...

        现在,两个线程各持有一把锁,而双方都想要获取对方手里的锁,造成了无限等待状态,即为死锁。

        当死锁放生之后,没有任何办法可以解决死锁,只能强制结束JVM进程。

产生死锁的四个条件:

        1.资源互斥:在同一时刻,一把锁只能被一个线程所持有;

        2.不可剥夺:当一个线程以获得了资源,在没有使用完之前,不能被剥夺,只能等待所持有资源的线程自行释放锁;

        3.请求等待:当一个线程想要请求其他资源发生阻塞时,对于自己所持有的资源也不释放;

        4.循环等待:多个线程之间的循环等待;

如何让避免死锁?

        1.每次只占用不超过1个锁;

        2.按照相同的顺序申请锁;

        3.使用信号量;

使用信号量解决死锁:

public class DeadLock {
	private Semaphore semaphoreA = new Semaphore(1);
	private Semaphore semaphoreB = new Semaphore(1);

	public void add() throws InterruptedException {
		semaphoreA.acquire();
		Thread.sleep(1000);
		semaphoreB.acquire();
		try {
			System.out.println("执行add()");
		} finally {
			semaphoreB.release();
			semaphoreA.release();
		}

	}

	public void dec() throws InterruptedException {
		while (semaphoreB.tryAcquire()) {
			Thread.sleep(100);
			if (semaphoreA.tryAcquire()) {
				try {
					System.out.println("执行dec()");
					return;
				} finally {
					semaphoreA.release();
					semaphoreB.release();
				}
			} else {
				semaphoreA.release();
				semaphoreB.release();
			}
		}
	}
}

你可能感兴趣的:(java,开发语言,eclipse)