架构师入门笔记六 初识线程安全锁

最新推荐文章于 2024-07-25 20:02:34 发布
最新推荐文章于 2024-07-25 20:02:34 发布
阅读量1.6k 收藏 1
点赞数 2
分类专栏： java java架构师入门 文章标签： 架构师 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_19558705/article/details/77073871
版权
 
架构师入门笔记六 初识线程安全锁
这章主要介绍Synchronized，ThreadLock，Lock，Concurrent.util等方法。
 

1 Lock 锁

在java多线程中，可以使用synchronized关键字实现线程间的同步互斥工作，而Lock对象，能更好地完成同步互斥的工作（灵活性高。在jdk1.8之前，性能比synchronized关键字好）。今天主要学习它的重入锁和读写锁。

1.1 ReentrantLock重入锁

重入锁，在需要进行同步的代码部分加上锁定，当不能忘记在最后一步要释放锁定，不然会造成锁永远无法释放，其他线程永远进不来的结果 
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyReentrantLock {
	
	private Lock lock = new ReentrantLock(); // 重入锁
	
	private void lockMethod() {
		try {
			lock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入lockMethod..");
			consoleTime("lockMethod" , 5);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出lockMethod..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	private void lockMethod2() {
		try {
			lock.lock();
			System.out.println("当前线程:" + Thread.currentThread().getName() + "进入lockMethod..");
			consoleTime("lockMethod2" , 3);
			System.out.println("当前线程:" + Thread.currentThread().getName() + "退出lockMethod..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final MyReentrantLock myLock = new MyReentrantLock();
		
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.lockMethod(); // 加锁后，该方法执行结束，释放锁后，才会执行下一个方法
				myLock.lockMethod2();
			}
		});
		thread.start();
	}
	
	private void consoleTime(String methodName, int num) {
		for (int i = num; i > 0; i--) {
			try {
				System.out.println(methodName + " : " + i + "s");
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}
从打印的结果可以看出，只有当LockMethod方法执行完了（锁释放了），才开始执行LockMethod2方法。

1.2 锁的等待与通知

Synchronized的等待与通知是通过wait() 和 notify() 方法结合使用实现的。而Lock对象这是则是通过Condition类来实现的。
单个Condition： 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyReentrantLock {
	
	private Lock lock = new ReentrantLock(); // 重入锁
	private Condition condition = lock.newCondition();  
	
	private void lockMethod() {
		try {
			lock.lock();
			System.out.println("当前线程：" + Thread.currentThread().getName() + " 进入等待状态..");
			consoleTime("lockMethod" , 3);
			System.out.println("当前线程：" + Thread.currentThread().getName() + " 释放锁..");
			condition.await();	// Object wait
			System.out.println("当前线程：" + Thread.currentThread().getName() +" 继续执行...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	private void lockMethod2() {
		try {
			lock.lock();
			System.out.println("当前线程：" + Thread.currentThread().getName() + " 进入..");
			consoleTime("lockMethod2" , 3);
			System.out.println("当前线程：" + Thread.currentThread().getName() + " 发出唤醒..");
			condition.signal();		//Object notify
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final MyReentrantLock myLock = new MyReentrantLock();
		
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.lockMethod(); // 加锁后，该方法执行结束，释放锁后，才会执行下一个方法
			}
		});
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.lockMethod2();
			}
		});
		thread.start();
		thread2.start();
	}
	
	private void consoleTime(String methodName, int num) {
		for (int i = num; i > 0; i--) {
			try {
				System.out.println(methodName + " : " + i + "s");
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}
从打印的结果可以看出，t1线程执行到await()方法后释放锁，t1线程开始等待，t2线程开始执行，执行到signal()方法后发出唤醒。
多个Condition（Lock锁比Synchronized灵活的原因）： 
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class UseManyCondition {

	private ReentrantLock lock = new ReentrantLock();
	private Condition c1 = lock.newCondition();
	private Condition c2 = lock.newCondition();
	
	public void m1(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m1等待..");
			c1.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m1继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m2(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m2等待..");
			c1.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m2继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m3(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "进入方法m3等待..");
			c2.await();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "方法m3继续..");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m4(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
			c1.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void m5(){
		try {
			lock.lock();
			System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");
			c2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		
		final UseManyCondition umc = new UseManyCondition();
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m1();
			}
		},"t1");
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m2();
			}
		},"t2");
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m3();
			}
		},"t3");
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m4();
			}
		},"t4");
		Thread t5 = new Thread(new Runnable() {
			@Override
			public void run() {
				umc.m5();
			}
		},"t5");
		
		t1.start();	// c1
		t2.start();	// c1
		t3.start();	// c2
		
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t4.start();	// c1
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t5.start();	// c2
	}
	
}
代码摘录网络，t1 ，t2线程 处于c1的等待中，t3线程处于c2的等待中。t4线程负责唤醒全部c1的等待线程。t5线程负责唤醒t3线程。可以从打印的结果中清晰看出 
当前线程：t1进入方法m1等待..
当前线程：t2进入方法m2等待..
当前线程：t3进入方法m3等待..
当前线程：t4唤醒..
当前线程：t1方法m1继续..
当前线程：t2方法m2继续..
当前线程：t5唤醒..
当前线程：t3方法m3继续..

1.3 ReentrantReadWriteLock读写锁

读写锁 ReentrantReadWriteLock，其核心就是实现读写分离的锁，在高并发访问下，尤其是读多写少的情况，性能要远高于重入锁。之前学习的Synchronized、ReentrantLock时，同一时间内，只能有一个线程进行访问被锁定的代码，那么读写锁则不同，其本质是分离成两个锁，即读锁和写锁。在读锁下，多个线程可以并发的进行访问，但是在写锁的时候，只能一个一个的顺序访问。 
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class MyReentrantReadWriteLock {
	
	private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(); // 读写锁
	private ReadLock readLock = readWriteLock.readLock(); // 读锁
	private WriteLock writeLock = readWriteLock.writeLock(); // 写锁
	
	private void read() {
		try {
			readLock.lock();
			System.out.println("当前读线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前读线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			readLock.unlock();
		}
	}
	
	public void write(){
		try {
			writeLock.lock();
			System.out.println("当前写线程:" + Thread.currentThread().getName() + "进入...");
			Thread.sleep(3000);
			System.out.println("当前写线程:" + Thread.currentThread().getName() + "退出...");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			writeLock.unlock();
		}
	}

	public static void main(String[] args) {
		final MyReentrantReadWriteLock myLock = new MyReentrantReadWriteLock();
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.read();
			}
		});
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.read();
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.write();
			}
		});
		Thread t4 = new Thread(new Runnable() {
			@Override
			public void run() {
				myLock.write();
			}
		});
		
		// t1 和 t2 是读方法，t3 和 t4 是写方法
		System.out.println("读 * 读操作");
		t1.start();
		t2.start();
//		System.out.println("读 * 写操作");
//		t1.start();
//		t3.start();
//		System.out.println("写 * 写操作");
//		t3.start();
//		t4.start();
	}
通过打印的情况，可以看出，只有读*读的时候，两个线程是同时执行，而其他情况都是有先后顺序的。
 
 

2 ThreadLocal

ThreadLocal为变量在每个线程中都创建了一个跟特定线程有关的变量的副本，这样就可以使每个线程在运行中只可以使用与自己线程有关的特定的副本变量，而不会影响其它线程的副本变量，保证了线程间变量的隔离性。
ThreadLocal 和 Synchronized的区别在于，ThreadLocal是将数据在多线程中隔离开，而Synchronized是将数据在多线程中实现共享。
 

3 Concurrent.utils 常用方法

3.1 CountDownLacth

CountDownLacth：用于监听初始化操作，等初始化执行完毕后，通知主线程继续工作。 
import java.util.concurrent.CountDownLatch;

public class UseCountDownLatch {

	public static void main(String[] args) {
		// CountDownLatch 中的值，可以尝试用1，2，3执行结果，会发现如果填入的值是1，t2线程执行完毕后，t1就继续执行了
		// 如果填入的值是3，t2和t3都执行完毕了，t1线程还未执行。
		final CountDownLatch countDown = new CountDownLatch(2);
		
		Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println("进入线程t1" + "等待其他线程处理完成...");
					countDown.await();
					System.out.println("t1线程继续执行...");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"t1");
		
		Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println("t2线程进行初始化操作...");
					Thread.sleep(3000);
					System.out.println("t2线程初始化完毕，通知t1线程继续...");
					countDown.countDown();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println("t3线程进行初始化操作...");
					Thread.sleep(4000);
					System.out.println("t3线程初始化完毕，通知t1线程继续...");
					countDown.countDown();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		
		t1.start();
		t2.start();
		t3.start();
	}
}
现在只是初识 CountDownLacth 方法（入门），在之后学习zookeeper的时候会详细简介。

3.2 CyclicBarrier

CyclicBarrier：当每个线程都准备好了，每个线程再执行。 
import java.io.IOException;  
import java.util.Random;  
import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors; 
public class UseCyclicBarrier {

	static class Runner implements Runnable {  
	    private CyclicBarrier barrier;  
	    private String name;  
	    
	    public Runner(CyclicBarrier barrier, String name) {  
	        this.barrier = barrier;  
	        this.name = name;  
	    }  
	    @Override  
	    public void run() {  
	        try {  
	            Thread.sleep(1000 * (new Random()).nextInt(5));  
	            System.out.println(name + " 准备OK.");  
	            barrier.await();  
	        } catch (InterruptedException e) {  
	            e.printStackTrace();  
	        } catch (BrokenBarrierException e) {  
	            e.printStackTrace();  
	        }  
	        System.out.println(name + " 开始执行!!");  
	    }  
	} 
	
    public static void main(String[] args) throws IOException, InterruptedException {  
        CyclicBarrier barrier = new CyclicBarrier(3);  // 3 
        ExecutorService executor = Executors.newFixedThreadPool(3); // 如果线程此不足3个，只要有一个线程没有准备好，其他线程都不会执行 
        
        executor.submit(new Thread(new Runner(barrier, "t1")));  
        executor.submit(new Thread(new Runner(barrier, "t2")));  
        executor.submit(new Thread(new Runner(barrier, "t3")));  
        executor.shutdown();  
    }  
  
}

3.3 Future

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class UseFuture implements Callable<String>{
	private String para;
	
	public UseFuture(String para){
		this.para = para;
	}
	
	@Override
	public String call() throws Exception {
		//模拟执行耗时 .这里是真实的业务逻辑，其执行可能很慢
		Thread.sleep(5000);
		String result = this.para + "处理完成";
		return result;
	}
	
	//主控制函数
	public static void main(String[] args) throws Exception {
		//构造FutureTask，并且传入需要真正进行业务逻辑处理的类,该类一定是实现了Callable接口的类
		FutureTask<String> futureTask = new FutureTask<String>(new UseFuture("query"));
		FutureTask<String> futureTask2 = new FutureTask<String>(new UseFuture("update"));
		//创建一个固定线程的线程池且线程数为1,
		ExecutorService executor = Executors.newFixedThreadPool(2);
		//这里提交任务future,则开启线程执行RealData的call()方法执行
		//submit和execute的区别： 第一点是submit可以传入实现Callable接口的实例对象， 第二点是submit方法有返回值
		Future future1 = executor.submit(futureTask);		//单独启动一个线程去执行的，异步
		Future future2 = executor.submit(futureTask2);
		System.out.println("Future 异步请求完毕");
		
		//这里可以做额外的数据操作，也就是主程序执行其他业务逻辑
		System.out.println("处理实际的业务逻辑...");
		Thread.sleep(5000);
		//调用获取数据方法,如果call()方法没有执行完成,则依然会进行等待
		System.out.println("数据：" + futureTask.get()); // get() 方法获取实际结果
		System.out.println("数据：" + futureTask2.get());
		
		executor.shutdown();
	}

}
 
 
 
 
以上便是线程锁，并附带了其他相关的知识，方便自己查阅，同时也希望能帮助到读者。下一章讲解有关并发框架Disruptor知识。更多干货尽在  ITDragon博客
 
 
 
 
ITDragon龙
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 线程安全 锁
FREEDOM
05-30 766
两个线程A，B。调用同一加锁代码块C，假如A先调用C，在A线程调用C完成之前，B线程要调用此代码块必须先等待，等A调用完成，B立马执行C. package test; import java.io.UnsupportedEncodingException; import java.math.BigInteger; import java.net.URLEncoder; import j
大数据、云计算系统顶级架构师课程学习路线图
spark798的博客
06-30 1547
大数据之Linux+大数据开发篇 Java Linux基础 Shell编程 Hadoop2.x HDFS YARN MapReduce ETL数据清洗Hive Sqoop Flume/Oozie 大数据WEB工具Hue HBase Storm Scala KafkaSpark Spark核心源码剖析 CM 5.3.x管理 CDH 5.3.x集群 想成为云计算大数据Spark高手，看这里！...
架构师入门笔记九 初识IO NIO AIO
ITDragon博客
09-15 1853
架构师入门笔记九 初识IO NIO AIO 在学习netty之前，我们要对Socket网络编程有一定的了解。这里先来了解一下 IO（BIO），NIO，AIO（NIO2.0）这几种通信的特点以及其演变的过程。 1 IO（BIO） 1.1 基础理论 IO（input/output）又称BIO（block-IO）,BIO通信模型是同步阻塞的通信模式。 Socket 又称“套
线程、线程安全、线程同步、锁、线程池
最新发布
Er222220的博客
07-25 664
当对象被反序列化时，这些变量的值不会恢复，而是被初始化为其默认值（例如，数字类型为 0，对象类型为 null，布尔类型为 false）在 Java 中，volatile 关键字用于修饰变量，确保对该变量的读写操作都是直接从主存中进行的，而不是从而不是线程的工作内存中。这是一个动态的过程：有自身的产生、存在和消亡的过程，这也是进程的生命周期。线程池中的线程达到（超过）核心线程数，超出的数量会根据存活时间，进行销毁，直到数量达到核心线程数，如果线程的数量少于核心线程数，不会消亡。
java-多线程安全-锁
刘望的博客
01-16 226
一 同步函数 1.1 一般的方法 同步的另一种体现形式：同步函数。 同步函数使用的锁是哪个？经过分析：大概猜的是this，因为函数必须被对象调用。 验证：写一个同步代码块，写一个同步函数，如果同步代码块中的锁对象和同步函数中的锁对象是同一个，就同步了，就没有错误的数据了。如果不是同一个锁对象，就不同步出现错误数据。 让两个线程，一个线程在同步代码块中执行，一个线程在同步函数中执...
线程安全——锁
Z1591090的博客
07-19 1956
前言 多线程利用CPU多核的性质。能并行执行任务，提高效率。但随着多线程的使用，对于资源的静态以及数据的操作都可能存在风险，所以有必要在操作时保证线程安全。而线程的安全主要是依靠各种锁，锁的种类有很多，有各自的优缺点，需要开发者自己权衡利弊，选择合适的锁，来搭配多线程的使用。 NSLock ...
架构师入门笔记一 初识线程关键字
ITDragon博客
08-04 7704
架构师入门笔记一 初识线程关键字 本章主要介绍线程的关键字 synchronized，volatile 的含义，使用方法和使用场景，以及注意事项。下一章介绍线程的队列知识。 首先要了解线程安全概念：当多个线程访问某一个类（对象或方法）时，这个对象始终都能表现出正确的行为，那么这个类（对象或方法）就是线程安全的。 关键字 synchronized synchronized 可以在任意对象及
《后端架构师技术图谱》
weixin_70730532的博客
06-15 772
（Toc generated by simple-php-github-toc ）《java队列——queue详细分析》《LinkedList、ConcurrentLinkedQueue、LinkedBlockingQueue对比分析》每个节点最多有两个叶子节点。左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree）。MySQL是
JavaEE系统架构师学习路线(基础篇)
wu8110448的博客
03-28 770
大纲： 第1阶段(Java程序员) - Java语言基础 第2阶段(Java初级软件工程师) - JSP、Servlet、HTML、CSS、JS、Bootstrap、XML、AJAX、MySQL、SQL Server、Oracle 第3阶段(Java中级软件工程师) - Struts2、Spring、Hibernate、SpringMVC、Mybatis、Shiro、JVM 第4阶段(J...
大数据、云计算系统高级架构师课程学习路线图
juan188的博客
02-20 1639
大数据之Linux+大数据开发篇   大数据的前景和意义也就不言而喻了，未来，大数据能够对大量、动态、能持续的数据，通过运用新系统、新 工具、新模型的挖掘，从而获得具有洞察力和新价值的东西。源于互联网的发展，收集数据的门槛越来越低， 收集数据变成一件简单的事情，这些海量的数据中是含有无穷的信息和价值的，如何更好的提炼出有价值的信 息，这就体现大数据的用途了。 大数据是未来的发展方向，正在...
JavaEE系统架构师学习路线之基础篇
qq_42709274的博客
07-17 882
大纲： 第1阶段(Java程序员) - Java语言基础 第2阶段(Java初级软件工程师) - JSP、Servlet、HTML、CSS、JS、Bootstrap、XML、AJAX、MySQL、SQL Server、Oracle 第3阶段(Java中级软件工程师) - Struts2、Spring、Hibernate、SpringMVC、Mybatis、Shiro、JVM 第4阶段(J...
线程安全（锁）
Yangll29的博客
06-09 295
撰写时间：2019年06月04日 Mysql的引擎 mysql-5.5.5开始，InnoDB 作为默认存储引擎，以前是MyISAM引擎 MyISAM引擎和InnoDB引擎的比较： MyISAM 是非事务安全型的，而 InnoDB 是事务安全型的。 MyISAM 锁的粒度是表级，而 InnoDB 支持行级锁定。 MyISAM 支持全文类型索引，而 InnoDB 不支持全文索引。 ...
架构师入门笔记十 Netty5快速入门
M_Jack的博客
06-01 405
在了解IO，NIO，AIO知识后，学习Netty5便会轻松很多，本章节主要介绍Netty是如何接收，反馈数据和拆包粘包的问题。1 Netty基础知识1.1 Netty作用Netty是一个提供异步事件驱动的网络应用框架，用以快速开发高性能、高可靠性 的网络服务器和客户端程序。Netty是一个NIO框架，使用它可以简单快速地开发网络应用程序，比如客户端和服务端的协议。Netty简化了网络程序的开发过程...
架构师入门笔记三 初识Queue队列
ITDragon博客
08-10 2513
架构师入门笔记三 初识Queue队列 1.wait和notify模拟Queue 1.1 wait / notify 基础知识 线程通信概念：线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理，就不能成为一个整体，线程之间的通信就成为整体的必用方法之一。 使用 wait/ notify 方法实现线程间的通信： 1）wait 和 notify 必须要配合 synchroni
线程安全和锁
weixin_44586512的博客
06-10 173
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; namespace Test { class Demo2 { //线程之间可以通过static变量来共享数据。 priv...
Java线程安全和锁
itakyubi的博客
08-26 198
目录 1、CAS算法 2、Synchronized实现原理 3、锁优化 (1) 自旋锁 (2) 适应性自旋锁 (3) 锁消除 (4) 锁粗化 (5) 偏向锁 (6) 轻量级锁 (7) 乐观锁 (8) 悲观锁 4、i++是否线程安全 1、CAS算法 Cas(Compare and Swap)，传入有三个值V、a、b，V是内存值，a是预期值，b是更新值...
线程安全（一）Java锁（锁分类、锁升级、锁优化）
ACGkaka的博客
07-08 901
线程安全（一）Java锁（锁分类、锁升级、锁优化）
线程安全、死锁、synchronized锁、lock锁
linxi438的博客
03-07 392
当一个线程第一次运行到synchronize代码，获取到了 myObject对象的monitor锁，然后计数器就会+1，然后同一个线程第二次运行到synchronize代码，会再次获取到 myObject对象的monitor锁，这个就是重入加锁，计算器在加1，变成2，这个时候其他线程运行到第一次synchronize代码，会发现 myObject对象的monitor锁的计数器是大于0的，意味着被别人给加锁了，线程就会进入block阻塞状态，等待获取锁。1.lock是JUC包下提供封装好的锁，是类的概念；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值