深入理解Java多线程（各种方法和生命周期）和各种锁（自旋锁、轻量级锁、重量级锁、读写锁、可重入锁、公平锁、可中断锁等）

最新推荐文章于 2024-07-15 14:54:23 发布
最新推荐文章于 2024-07-15 14:54:23 发布
阅读量630 收藏 4
点赞数 1
分类专栏： Java 文章标签： 多线程 锁机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38638148/article/details/82353527
版权

上一篇博客写了Java的内存模型和Java多线程底层的一些东西，但是总是感觉有点理论化，平时用线程方面的知识根本就没有用过一样。所以这一篇来总结一下我们用到的多线程知识。

首先创建线程：

俩种方式

1.继承Thread类重写run() 方法 

public class FirstThread extends Thread{

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			
			System.out.println("这是"+this.getName()+"线程");
		}
	}

	
	
}

2.实现Runnable接口重写run() 方法 

public class SecondThread implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("这是secondThread线程");
		}
		
	}

}

虽然是俩种创建方式，但是Thread其实也是实现了Runnable接口的

class Thread implements Runnable 

而我们都知道要想使线程处于就绪状态，就得调用他的start()方法，而Runnable中只有一个方法那就是run方法，所以要用Runnable来创建线程后还得再用Thread类来转化一下。如下：

public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {
		SecondThread st=new SecondThread();
		FirstThread ft=new FirstThread();
		Thread td=new Thread(st);
		td.start();
		ft.start();
	}

这是创建线程，那么线程的生命周期是什么呢？

主要有5种生命状态：1.线程的创建 2.就绪状态 3.运行状态  4.阻塞状态  5.终止状态

当我们使用new创建了一个线程实例时，这是线程处于创建状态，而当调用了start方法之后线程会正式进入就绪状态，当此线程抢到了cpu之后就会进入到运行状态，然后要是顺利的话，就可以一直到运行结束，进入死亡状态，要是不顺利的话比如调用了wait()方法就会出现阻塞状态(这之后会详细介绍)。

接下来就是线程的几个常用方法了。在此之前先运行一下之前的俩个线程。

这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程

public static native void yield();

public static native Thread currentThread();

public static native void sleep(long millis) throws InterruptedException;

public final synchronized void join(long millis)

public final native boolean isAlive();

public final synchronized void setName(String name)

 public final String getName() 

public final int getPriority()

public final void setPriority(int newPriority) 

接下来一个一个演示这些方法的作用：

1.yield()此方法的作用是让当前线程放弃CPU的使用权，转而变成就绪状态再次和其他线程抢夺cpu资源（有些文章上面会说此方法会让出cpu给其他同等级的线程使用，然后此线程便不再参与争夺，我经过验证觉得这种说法不太严谨，贴出我的代码）

public class YieldTest implements Runnable{

	private String name;
	public YieldTest(String name) {
		this.name=name;
	}
	
	
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
			if(i==0) {
				Thread.yield();
			}
		}
	}
//上面是Runnable类中的东西
	public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {
		Thread t1=new Thread(new YieldTest("t1"));
		Thread t2=new Thread(new YieldTest("t2"));
		t1.start();
		t2.start();
	}
结果为
Thread-1:0
Thread-0:0
Thread-1:1
Thread-0:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-0:2
Thread-1:5
Thread-0:3
Thread-1:6
Thread-1:7
Thread-1:8
Thread-1:9
Thread-1:10
Thread-1:11
Thread-1:12
Thread-1:13
Thread-1:14
Thread-1:15
Thread-1:16
Thread-1:17
Thread-1:18
Thread-1:19
Thread-1:20
Thread-1:21
Thread-1:22
Thread-1:23
Thread-1:24
Thread-1:25
Thread-1:26
Thread-1:27
Thread-1:28
Thread-1:29
Thread-1:30
Thread-1:31
Thread-1:32
Thread-1:33
Thread-1:34
Thread-1:35
Thread-1:36
Thread-1:37
Thread-1:38
Thread-1:39
Thread-1:40
Thread-1:41
Thread-1:42
Thread-1:43
Thread-1:44
Thread-1:45
Thread-1:46
Thread-1:47
Thread-1:48
Thread-1:49
Thread-1:50
Thread-1:51
Thread-1:52
Thread-1:53
Thread-0:4
Thread-1:54
Thread-0:5
Thread-1:55
Thread-0:6
Thread-0:7
Thread-0:8
Thread-0:9
Thread-0:10
Thread-0:11
Thread-0:12
Thread-0:13
Thread-0:14
Thread-0:15
Thread-0:16
Thread-0:17
Thread-0:18
Thread-0:19
Thread-0:20
Thread-0:21
Thread-0:22
Thread-0:23
Thread-0:24
Thread-0:25
Thread-0:26
Thread-0:27
Thread-0:28
Thread-0:29
Thread-0:30
Thread-0:31
Thread-0:32
Thread-0:33
Thread-0:34
Thread-0:35
Thread-0:36
Thread-0:37
Thread-0:38
Thread-0:39
Thread-0:40
Thread-0:41
Thread-0:42
Thread-0:43
Thread-0:44
Thread-0:45
Thread-0:46
Thread-0:47
Thread-0:48
Thread-0:49
Thread-0:50
Thread-0:51
Thread-0:52
Thread-0:53
Thread-0:54
Thread-0:55
Thread-0:56
Thread-0:57
Thread-0:58
Thread-0:59
Thread-0:60
Thread-0:61
Thread-0:62
Thread-0:63
Thread-0:64
Thread-0:65
Thread-0:66
Thread-0:67
Thread-0:68
Thread-0:69
Thread-0:70
Thread-0:71
Thread-0:72
Thread-0:73
Thread-0:74
Thread-0:75
Thread-0:76
Thread-0:77
Thread-0:78
Thread-0:79
Thread-0:80
Thread-0:81
Thread-0:82
Thread-0:83
Thread-0:84
Thread-0:85
Thread-0:86
Thread-0:87
Thread-0:88
Thread-0:89
Thread-0:90
Thread-0:91
Thread-0:92
Thread-0:93
Thread-0:94
Thread-0:95
Thread-0:96
Thread-0:97
Thread-0:98
Thread-0:99
Thread-1:56
Thread-1:57
Thread-1:58
Thread-1:59
Thread-1:60
Thread-1:61
Thread-1:62
Thread-1:63
Thread-1:64
Thread-1:65
Thread-1:66
Thread-1:67
Thread-1:68
Thread-1:69
Thread-1:70
Thread-1:71
Thread-1:72
Thread-1:73
Thread-1:74
Thread-1:75
Thread-1:76
Thread-1:77
Thread-1:78
Thread-1:79
Thread-1:80
Thread-1:81
Thread-1:82
Thread-1:83
Thread-1:84
Thread-1:85
Thread-1:86
Thread-1:87
Thread-1:88
Thread-1:89
Thread-1:90
Thread-1:91
Thread-1:92
Thread-1:93
Thread-1:94
Thread-1:95
Thread-1:96
Thread-1:97
Thread-1:98
Thread-1:99

原谅我一下给贴出来了，但是是为了证明我的验证的正确性，使用yield方法会使当前正在运行的线程让出cpu，转而进入就绪状态，会再次与其他线程争夺cpu，所以它完全有可能会再次执行。

2.currentThread()

此方法是Thread的静态方法，作用是返回当前正在使用cpu资源的线程，验证代码如下：

public class YieldTest implements Runnable{

	private String name;
	public YieldTest(String name) {
		this.name=name;
	}
	
	
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("当前线程的引用："+Thread.currentThread()+"-----"+Thread.currentThread().getName()+":"+i);
			
			if(i==0) {
				Thread.yield();
			}
		}
	}

	
	
}
主方法为：
public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {
		Thread t1=new Thread(new YieldTest("t1"));
		Thread t2=new Thread(new YieldTest("t2"));
		t1.start();
		t2.start();
	}
运行结果：
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:0
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:1
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:2
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:3
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:4
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:5
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:6
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:7
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:8
当前线程的引用：Thread[Thread-0,5,main]-----Thread-0:9
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:0
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:1
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:2
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:3
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:4
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:5
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:6
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:7
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:8
当前线程的引用：Thread[Thread-1,5,main]-----Thread-1:9

3.sleep(long millis)：此方法是让线程进入休眠状态，但是不放弃对象锁（与wait的区别），注意：参数的单位是毫秒，到达时间之后会自动进入就绪状态。

public class SecondThread implements Runnable{

	@Override
	public void run() {
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		for (int i = 0; i < 10; i++) {
			System.out.println("这是secondThread线程");
		}
		
	}

}

public class FirstThread extends Thread{

	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			
			System.out.println("这是"+this.getName()+"线程");
		}
	}

	
	
}

public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {
		FirstThread ft=new FirstThread();
		SecondThread st=new SecondThread();
		Thread st1=new Thread(st);
		st1.start();
		ft.start();
	}

这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程

4.join()：此方法比较难理解一点结合代码看。

public static void main(String[] args) throws ClassNotFoundException, IOException, InterruptedException {
		FirstThread ft=new FirstThread();
		SecondThread st=new SecondThread();
		Thread st1=new Thread(st);
		st1.start();
		st1.join();
		ft.start();
	}
	
//这里只贴出主方法，因为俩个线程类在上面贴过了。
结果为：
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是secondThread线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程
这是Thread-0线程

其实Thread类中的join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。这个串行并不是我们使用锁那种理解，如上当在主方法中执行st1的join方法时，那么主方法将会等着st1中执行完毕才会继续向下执行，也就是执行ft这个线程。

它还有一个重载的方法就是join（long millis）单位是毫秒

此方法和join（）基本一致，就是主线程会等st1milis时间后，他会再次和st1争夺cpu，当然此方法使用时要注意的是不能放在start()方法前面，否则无效。

剩下的几个方法

public final native boolean isAlive();   //判断线程是否活着

public final synchronized void setName(String name)//设置线程的名字

 public final String getName() //获取线程的名字

public final int getPriority()//获取线程的优先级

public final void setPriority(int newPriority) //设置线程的优先级

关于线程的优先级这里就不详细说了，因为Java跨平台的原因，所以优先级不一定有效，而且我们平时也很少使用。

就下来就是线程同步的问题。

先看和线程同步有关的方法有哪些？

1.sleep()

2.yield()

3.wait()   //这个方法是Object类中的方法，使用它时会使当前正在使用cpu资源的线程堵塞，并且它堵塞线程之后，线程不会自己返回到就绪状态，而是等待notify或notifyAll方法将其返回到就绪状态。此方法释放对象锁。

4.notify()  //此方法用来释放wait方法引起的堵塞现象，只能解放一个由wait引起堵塞的线程。

5.notifyAll()  //此方法可以解放所有由wait引起堵塞的线程。

以上三个方法会在下面生产者和消费者例子中使用，这里不详细说。

了解了线程同步方法以及同步原理之后，我们可以来看看同步的实例：

public class Produce implements Runnable{

	private Apple apple;
	public Produce(Apple apple) {
		this.apple=apple;
	}
	
	@Override
	public void run() {
		for(int i=0;i<5;i++) {
			try {
				apple.increace();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}

	
	
}
//此为生产者
public class Customer implements Runnable{

	private Apple apple;
	public Customer(Apple apple) {
		this.apple=apple;
	}
	
	@Override
	public void run() {
		
		for(int i=0;i<5;i++) {
			apple.recreate();;
		}
		
	}
	
}
//此为消费者
public class Apple{

	private int apple=0;
	
	
	public synchronized void increace() throws InterruptedException {
		while(apple==5) {
			try {
				notify();//先换醒其他线程，在关掉当前线程	
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
		apple++;
		System.out.println("生产苹果成功");
		
	}
	public void recreate() {
		while(apple==0) {
			try {
				notify();
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
		}
		apple--;
		System.out.println("消费成功");
		
	}
}
//此为他们的共享变量
生产苹果成功
生产苹果成功
生产苹果成功
生产苹果成功
生产苹果成功
消费成功
消费成功
消费成功
消费成功
消费成功

此为结果

注意wait(),notify(),notifyAll()这些方法只能在synchronized关键字里面使用。

生产者和消费者是一个最典型的的不同线程之间进行变量共享，并且保持数据同步的一个例子。

到这里线程的生命周期和线程的几个方法以及和线程同步的几个方法就已经讲完了。

接下来就是几个关于锁机制的几个关键字了。

来看这俩个synchronized和volatile，这俩个关键字都是可以做到变量共享的，synchronized这个大家应该非常熟悉，而volatile这个关键字的话在我的上一篇博客里面有详细介绍，所以有不清晰的可以去那里看一看。

那么Java的线程锁呢，又有哪些呢？

java包含两种锁机制：synchronized和java.util.concurrent.Lock。

此为多线程内置的关键字，而Lock则是一个接口。

接下来先介绍几个锁概念

1.可重入锁：如果A方法中调用了B方法，如果A方法获取了该类的锁，在执行到调用B方法时，可以直接执行而不用再去申请锁。这种情况下我们称之为可重入锁。

2.可中断锁：Lock是可中断锁，synchronized不是，其它线程在等待锁的时候可以中断当前等待就是可中断，说的有点笼统，意思就是当A线程正在使用锁，B线程也本来也想使用锁，但是等的时间有点长了，于是B线程就开始想先做其他事，所以就开始中断等锁这一行为。

3.公平锁：如果有10个线程在等待锁A释放，此时如果锁A释放了，那么这是个线程谁等待的时间久，那么将会获得锁，

synchronized是非公平锁，Lock默认也是非公平锁，但是Lock可以在创建的时候设置。

4.读写锁：读写锁讲一个资源的访问分成了两个锁，读锁和写锁

ReadWriteLock就是一个读写锁，是个接口，子类有：ReenTrantReadWriteLock,可以通过readLock()获取读锁，通过

writeLock()获取写锁

读锁和写锁的互斥关系：

持有读锁时，不能持有写锁

持有写锁时，不能持有读锁

可多线程共同持有读锁，只有单一线程可持有写锁

持有写锁的前提是，没有一个线程持有读锁

持有读锁的前提是，没有一个线程持有写锁

锁升级：读锁--写锁，此处需要先释放读锁

锁降级：写锁--读锁，此处需要先获取读锁，然后再释放写锁（防止其它线程获取写锁后，修改数据，造成脏数据）

（这一段懒得打了，于是就偷了大神的总结，文章结束会将大神博客贴出来）

5.非公平锁：遵循的是线程抢占式调度，没有什么等待时间长，就优先之类的说法

还有几个锁，但是得先理解一下几个概念：

户态和核心态

两个操作系统的概念，用户态，核心态 
（1）当一个任务（进程）执行系统调用而陷入内核代码中执行时，称进程处于内核运行态（内核态）。 
（2）当进程在执行用户自己的代码时，则称其处于用户运行态（用户态）。

线程阻塞的代价 
　　java的线程是映射到操作系统原生线程之上的，如果要阻塞或唤醒一个线程就需要操作系统介入，需要在户态与核心态之间切换，这种切换会消耗大量的系统资源，因为用户态与内核态都有各自专用的内存空间，专用的寄存器等，用户态切换至内核态需要传递给许多变量、参数给内核，内核也需要保护好用户态在切换时的一些寄存器值、变量等，以便内核态调用结束后切换回用户态继续工作。

　　如果线程状态切换是一个高频操作时，这将会消耗很多CPU处理时间； 
　　如果对于那些需要同步的简单的代码块，获取锁挂起操作消耗的时间比用户代码执行的时间还要长，这种同步策略显然非常糟糕的。

为了防止上面出现的高频切换线程而带来的资源损耗问题所以有了下面几个锁：

自旋锁：所谓自旋锁，就是让该线程等待一段时间，不会被立即挂起，看持有锁的线程是否会很快释放锁。怎么等待呢？执行一段无意义的循环即可（自旋）。

目的是为了在短时间内不让一个没有得到锁的线程进行切换，但如果时间一长还是会出现相应的问题的。

 

轻量级锁：自旋锁的目标是降低线程切换的成本。如果锁竞争激烈，我们不得不依赖于重量级锁，让竞争失败的线程阻塞；如果完全没有实际的锁竞争，那么申请重量级锁都是浪费的。轻量级锁的目标是，减少无实际竞争情况下，使用重量级锁产生的性能消耗，包括系统调用引起的内核态与用户态切换、线程阻塞造成的线程切换等。（也就是虽然在多个线程下面，但是每个线程对锁的获取没有竞争，或者说有竞争但是完全可以控制住，这是完全不需要重量级锁来每次都切换线程，所以使用了轻量级锁）

偏向锁：在没有实际竞争的情况下，还能够针对部分场景继续优化。如果不仅仅没有实际竞争，自始至终，使用锁的线程都只有一个，那么，维护轻量级锁都是浪费的。偏向锁的目标是，减少无竞争且只有一个线程使用锁的情况下，使用轻量级锁产生的性能消耗。

总结来说：其实我觉得锁这种东西，更像是一种状态，达到某种状态了，给它个名字，然后叫锁了，一个关键字可能会造成几种状态，那么这是他也就会同时有了几种锁，一种状态可能包括了多种状态，比如悲观锁和乐观锁，就可以理解为一种状态，而比如说重量级锁偏向锁这些都属于悲观锁，就可以理解为一种状态中含有了多种状态。（个人理解）

其实锁还有很多，但是按这样理解就容易多了，其实没有刚刚学的时候那么难，就是一个抽象的概念，然后实现就是通过关键字或者参数调节有些本来就是默认这样的，其实没什么，还是那句话千万不要被抽象的概念吓到，很多东西远比想象的简单，只不过底层的知识没学过而已，慢慢地都能会的，加油。今天就到这了，还有几种锁的实现，以及优化，和线程并发时的一些问题明天再总结，明天结束线程。

参考资料：《Java2使用教材（第五版）》

https://www.jianshu.com/p/36eedeb3f912

https://blog.csdn.net/a314773862/article/details/54095819

https://blog.csdn.net/qq_41376740/article/details/80607243

https://www.cnblogs.com/dolphin0520/p/3923167.html

https://blog.csdn.net/qq_35877352/article/details/79415719

https://blog.csdn.net/u013144863/article/details/51392510

https://blog.csdn.net/qq_41247433/article/details/79434202

https://www.cnblogs.com/lcplcpjava/p/6896904.html

 

李铁拐
关注
专栏目录
13张图，带大家深入理解Synchronized|什么是锁粗化|锁消除|锁升级|偏向锁|轻量级锁|重量级锁
小小鱼儿小小林的博客
04-03 1607
目录 前言 内容大纲 Synchronized使用方式 普通函数 静态函数 代码块 Synchronized原理 Synchronized优化 锁粗化 锁消除 锁升级 偏向锁 轻量级锁 重量级锁 前言 Java并发编程系列第二篇Synchronized，文章风格依然是图文并茂，通俗易懂，本文带读者们由浅入深理解Synchronized，让读者们也能与面试官疯狂对线。 在并发编程中Synchronized一直都是元老级的角色，Jdk 1.6以前大家都称呼它为重量级锁，相.
Java多线程和并发编程面试题和参考答案100多道（持续更新）
大模型大数据攻城狮的专栏
05-20 210
守护线程（Daemon Thread）是一种特殊的线程，它在执行时不会阻止JVM的退出。当所有的非守护线程都结束运行时，JVM会自动退出，即使守护线程还在运行。守护线程主要用于执行一些后台任务，如垃圾回收、监控等。用途举例垃圾回收线程：JVM内部的垃圾回收线程就是一个典型的守护线程，它负责监控对象的使用情况，并在适当的时候回收不再使用的对象，释放内存资源。日志记录线程。
自旋锁
qq_39790702的博客
09-14 1732
-自旋锁 一、自旋锁概念 自旋锁实现在多处理器情况下保护临界区。自旋锁实际上是忙等待锁，被自旋锁保护的临界区代码执行时不能进入睡眠状态,他不能因为任何原因放弃处理器，除了服务中断；被自旋锁保护的临界区代码执行时，内核不能被抢占。 单CPU不支持内核抢占→空操作； 单CPU并支持内核抢占→对内核抢占功能的打开和关闭； SMP系统上，不仅对内核抢占的禁止，还需要在内存加一个标志，每个需要进入临界区的代码都必须检查这个标志，看临界区中是否有进程。 在Linux中，每个自旋锁都用spinlock_t表示： 内
java中各类锁的概念介绍(纯转载)
潮又落的博客
07-16 789
作者：Pickle Pee 链接：https://zhuanlan.zhihu.com/p/71156910 来源：知乎 著作权归作者所有，转载请联系作者获得授权。 网上关于Java中锁的话题可以说资料相当丰富，但相关内容总感觉是一大串术语的罗列，让人云里雾里，读完就忘。本文希望能为Java新人做一篇通俗易懂的整合，旨在消除对各种各样锁的术语的恐惧感，对每种锁的底层实现浅尝辄止，但是在需要时...
Java多线程（11） - 多线程 - 锁详解：重入锁、公平锁、非公平锁、读写锁、不可重入锁、自旋锁、独享锁、共享锁、互斥锁、悲观锁、乐观锁、分段锁、偏向锁、轻量级锁、重量级锁、CAS算法原理
Su_Levi_Wei的博客
05-29 428
重入锁：在需要进行同步的代码上加上锁定，但不要忘记最后一定要释放，不然会造成永远无法释放，其他线程永远无法进来 公平锁：多个线程按照先后申请顺序获得锁。 非公平锁：多个线程获取锁的顺序并不是按照申请锁的顺序，可能按照CPU获取的先后优先获取锁，有可能造成优先级翻转或饥饿的现象。 /** * 重入锁，必须要手动释放 */ public class L01ReentrantLock { public static vo...
Java并发篇乐观锁，悲观锁，自旋锁
06-26
- **轻量级锁**：在没有多线程竞争时，减少传统重量级锁的开销，适应线程交替执行同步块的场景。如果出现竞争，会膨胀为重量级锁。 - **偏向锁**：针对单线程频繁获取同一锁的情况，减少CAS操作，提高性能。一旦...
Java中55种锁，高级面试题，最新面试题
最新发布
Miss_SunHengYang的博客
07-15 2405
通过在适当的时候使用合适的锁类型（例如，在数据冲突可能性低时使用乐观锁，在冲突可能性高时转为悲观锁），混合锁可以减少不必要的资源竞争和锁等待，提高系统的并发性能和资源效率。网络锁通过网络通信协议在不同的系统节点之间传递锁的状态信息，使得不同节点可以在正确的时间获得锁，进行资源访问或修改，从而在分布式环境中实现资源的同步和一致性保证。在并发控制中，印章锁的乐观读模式允许多个线程同时进行读取操作，只有当写锁需要获取时，才会要求乐观读锁的线程重新验证戳或升级为悲观读锁，从而减少了读操作的锁竞争。
Java 并发编程解析 | 如何正确理解Java领域中的锁机制，我们一般需要掌握哪些理论知识？
weixin_44896262的博客
09-06 275
纵观Java领域中“五花八门”的锁，我们可以依据Java内存模型的工作机制，来具体分析一下对应问题的提出和表现，这也不失为打开Java领域中锁机制的“敲门砖”。从本质上讲，锁是一种协调多个进程 或者多个线程对某一个资源的访问的控制机制。在上述的内容中，一般常规的概念中，我们很难会依据上述这些问题去认识和看待Java中的锁机制，主要是在学习和查阅资料的时，大多数的论调都是零散和细分的，很难在我们的脑海中形成知识体系。
Spin lock 与mutex 的区别--2011.01.06
热门推荐
kyokowl的专栏
04-01 1万+
<br /><br />POSIX threads(简称Pthreads)是在多核平台上进行并行编程的一套常用的API。线程同步(Thread Synchronization)是并行编程中非常重要的通讯手段，其中最典型的应用就是用Pthreads提供的锁机制(lock)来对多个线程之间共 享的临界区(Critical Section)进行保护(另一种常用的同步机制是barrier)。<br /><br />Pthreads提供了多种锁机制：<br />(1) Mutex（互斥量）：pthread_mutex
【Linux-驱动】驱动策略----自旋锁
anpiga0111的博客
01-18 126
自旋锁 自旋锁最多只能被一个内核任务持有。要是锁未被持有，请求它的内核任务便会立即得到它并继续执行。如果一个内核任务试图请求一个已经被别的内核任务持有的自旋锁，那么CPU就会一直尽心循环---旋转---等待锁重新可用。 Spinlock_t my_lock = SPIN_LOCK_UNLOCKED; 或者在运行时使用： Void spin_lock_init(spinlock_t...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值