Java 中的锁如何使用？有什么注意事项？

最新推荐文章于 2023-08-04 14:43:32 发布
最新推荐文章于 2023-08-04 14:43:32 发布
阅读量367 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q309556032/article/details/101283216
版权

Java 中常见的锁有
synchronized
可重入锁 java.util.concurrent.lock.ReentrantLock
可重复读写锁 java.util.concurrent.lock.ReentrantReadWriteLock

synchronized 有 3种用法
修饰普通方法，执行方法代码，需要获取对象本身 this 的锁

package constxiong.concurrency.a18;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试 synchronized 普通方法
 * @author ConstXiong
 * @date 2019-09-19 10:49:46
 */
public class TestSynchronizedNormalMethod {

	private int count = 0;
	
//	private void add1000() {
	private synchronized void add1000() { //使用 synchronized 修饰 add100 方法，即可获得正确的值 30000
		for (int i = 0; i < 1000; i++) {
			count++;
		}
	}
	
	//启动 30 个线程，每个线程 对 TestSynchronized 对象的 count 属性加 1000
	private void test() throws InterruptedException {
		List<Thread> threads = new ArrayList<Thread>(10);
		
		for (int i = 0; i < 30; i++) {
			Thread t =  new Thread(() -> {
				add1000();
			});
			t.start();
			threads.add(t);
		}
		
		//等待所有线程执行完毕
		for (Thread t : threads) {
			t.join();
		}
		
		//打印 count 的值
		System.out.println(count);
	}
	
	public static void main(String[] args) throws InterruptedException {
		//创建 TestSynchronizedNormalMethod 对象，调用 test 方法
		new TestSynchronizedNormalMethod().test();
	}
}

修饰静态方法，执行方法代码，需要获取 class 对象的锁

package constxiong.concurrency.a18;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试 synchronized 静态方法
 * @author ConstXiong
 * @date 2019-09-19 10:49:46
 */
public class TestSynchronizedStaticMethod {

	private static int count = 0;
	
	private static void add1000() {
//	private synchronized static void add1000() { //使用 synchronized 修饰 add100 方法，即可获得正确的值 30000
		for (int i = 0; i < 1000; i++) {
			count++;
		}
	}
	
	public static void main(String[] args) throws InterruptedException {
		
		//启动 30 个线程，每个线程 对 TestSynchronized 对象的 count 属性加 1000
		List<Thread> threads = new ArrayList<Thread>(10);
		
		for (int i = 0; i < 30; i++) {
			Thread t =  new Thread(() -> {
				add1000();
			});
			t.start();
			threads.add(t);
		}
		
		//等待所有线程执行完毕
		for (Thread t : threads) {
			t.join();
		}
		
		//打印 count 的值
		System.out.println(count);
	}
}

锁定 Java 对象，修饰代码块，显示指定需要获取的 Java 对象锁

package constxiong.concurrency.a18;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试 synchronized 代码块
 * @author ConstXiong
 * @date 2019-09-19 10:49:46
 */
public class TestSynchronizedCodeBlock {

	private int count = 0;
	
	//锁定的对象
	private final Object obj = new Object();
	
	private void add1000() {
		
		//执行下面的加 1000 的操作，都需要获取 obj 这个对象的锁
		synchronized (obj) {
			for (int i = 0; i < 1000; i++) {
				count++;
			}
		}
	}
	
	//启动 30 个线程，每个线程 对 TestSynchronized 对象的 count 属性加 1000
	private void test() throws InterruptedException {
		List<Thread> threads = new ArrayList<Thread>(10);
		
		for (int i = 0; i < 30; i++) {
			Thread t =  new Thread(() -> {
				add1000();
			});
			t.start();
			threads.add(t);
		}
		
		//等待所有线程执行完毕
		for (Thread t : threads) {
			t.join();
		}
		
		//打印 count 的值
		System.out.println(count);
	}
	
	public static void main(String[] args) throws InterruptedException {
		//创建 TestSynchronizedNormalMethod 对象，调用 test 方法
		new TestSynchronizedCodeBlock().test();
	}
}

可重入锁 java.util.concurrent.lock.ReentrantLock 的使用示例

package constxiong.concurrency.a18;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试 ReentrantLock
 * @author ConstXiong
 * @date 2019-09-19 11:26:50
 */
public class TestReentrantLock {

	private int count = 0;
	
	private final Lock lock = new ReentrantLock();
	
	private void add1000() {
		lock.lock();
		try {
			for (int i = 0; i < 1000; i++) {
				count++;
			}
		} finally {
			lock.unlock();
		}
	}
	
	//启动 30 个线程，每个线程 对 TestSynchronized 对象的 count 属性加 1000
	private void test() throws InterruptedException {
		List<Thread> threads = new ArrayList<Thread>(10);
		
		for (int i = 0; i < 30; i++) {
			Thread t =  new Thread(() -> {
				add1000();
			});
			t.start();
			threads.add(t);
		}
		
		//等待所有线程执行完毕
		for (Thread t : threads) {
			t.join();
		}
		
		//打印 count 的值
		System.out.println(count);
	}
	
	public static void main(String[] args) throws InterruptedException {
		//创建 TestReentrantLock 对象，调用 test 方法
		new TestReentrantLock().test();
	}
	
}

可重复读写锁 java.util.concurrent.lock.ReentrantReadWriteLock 的使用示例

package constxiong.concurrency.a18;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
 
/**
 * 测试可重入读写锁 ReentrantReadWriteLock
 * @author ConstXiong
 * @date 2019-09-19 11:36:19
 */
public class TestReentrantReadWriteLock {
	
	//存储 key value 的 map
	private Map<String, Object> map = new HashMap<String, Object>();
	
	//读写锁
	private final ReadWriteLock lock = new ReentrantReadWriteLock();
	
	/**
	 * 根据 key 获取 value
	 * @param key
	 */
	public Object get(String key) {
		Object value = null;
		lock.readLock().lock();
		try {
			Thread.sleep(50L);
			value = map.get(key);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.readLock().unlock();
		}
		return value;
	}
	
	/**
	 * 设置key-value
	 * @param key
	 */
	public void set(String key, Object value) {
		lock.writeLock().lock();
		try {
			Thread.sleep(50L);
			map.put(key, value);
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.writeLock().unlock();
		}
	}


//测试5个线程读数据，5个线程写数据
public static void main(String[] args) {
	//创建测试可重入读写锁 TestReentrantReadWriteLock 对象
	TestReentrantReadWriteLock test = new TestReentrantReadWriteLock();
	
	String key = "lock";//存入 map 中的 key
	Random r = new Random();//生成随机数作为 value
	
	for (int i = 0; i < 5; i++) {
		//5 个线程读 map 中 key 的 value
		new Thread(() -> {
			for (int j = 0; j < 10; j++) {
				System.out.println(Thread.currentThread().getName() + " read value=" + test.get(key));
			}
		}).start();
		
		//5 个线程写 map 中 key 的 value
		new Thread(() -> {
			for (int j = 0; j < 10; j++) {
				int value = r.nextInt(1000);
				test.set(key, value);
				System.out.println(Thread.currentThread().getName() + " write value=" + value);
			}
		}).start();
	}
}

}

锁的使用注意事项
synchronized 修饰代码块时，最好不要锁定基本类型的包装类，如 jvm 会缓存 -128 ~ 127 Integer 对象，每次向如下方式定义 Integer 对象，会获得同一个 Integer，如果不同地方锁定，可能会导致诡异的性能问题或者死锁

Integer i = 100;

synchronized 修饰代码块时，要线程互斥地执行代码块，需要确保锁定的是同一个对象，这点往往在实际编程中会被忽视
synchronized 不支持尝试获取锁、锁超时和公平锁
ReentrantLock 一定要记得在 finally{} 语句块中调用 unlock() 方法释放锁，不然可能导致死锁
ReentrantLock 在并发量很高的情况，由于自旋很消耗 CPU 资源
ReentrantReadWriteLock 适合对共享资源写操作很少，读操作频繁的场景；可以从写锁降级到读锁，无法从读锁升级到写锁

喜欢的可以关注的公众号，java小瓜哥的分享平台
会不定时的推送技术文！大量的干货！
谢谢！

java后端
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中提升锁性能及锁的优化注意事项
qq_43012792的博客
09-02 1万+
一、减少锁持有时间 对于使用锁进行并发控制的应用程序来说，如果单个线程特有锁的时间过长，会导致锁的竞争更加激烈，会影响系统的性能。在程序中需要尽可能减少线程对锁的持有时间，如下面伪代码: public synchronized void syncMethod() { otherCode1(); //不需要进行同步加锁的方法，但是它需要的执行时间很长 mutexMethod(); //需要进行同步加锁的方法 other
Java 高并发九：锁的优化和注意事项详解
09-01
Java高并发编程中，锁的优化与注意事项是关键议题，特别是在多线程环境下，正确地使用锁能够确保程序的正确性和提升系统性能。本文将详细探讨锁优化的思路与方法，虚拟机内的锁优化策略，一个错误使用锁的案例，以及...
java中锁的使用
红豆和绿豆的博客
11-25 786
1、悲观锁 package concurrent; import java.util.concurrent.TimeUnit; public class SynchroniedTest { public static int a=0; public synchronized static int getAIncreament(){ Synchron
java同步锁如何使用_java 同步锁（synchronized）的正确使用姿势
weixin_39954698的博客
02-24 250
关于线程安全，线程锁我们经常会用到，但你的使用姿势正确不，反正我用错了好长一段时间而不自知。所以有了这篇博客总结下线程锁的正确打开姿势 废话不说看例子 一，对整个方法进行加锁 1，对整个方法进行加锁，不同线程访问同一个类的同一个对象public class TestRunnable implements Runnable {@Overridepublic synchronized v...
java 如何锁button_Java 中的锁如何使用？有什么注意事项？
weixin_42355570的博客
02-16 191
packageconstxiong.concurrency.a18;importjava.util.HashMap;importjava.util.Map;importjava.util.Random;importjava.util.concurrent.locks.ReadWriteLock;importjava.util.concurrent.locks.ReentrantReadWriteL...
java 锁的使用
小罗
02-16 303
/** * 锁的使用很简单 * 1：申请锁 / 锁定代码 * 2：释放锁 可以代替synchronize */ public class ReentrantLockTest { Lock lock = new ReentrantLock();//重入锁 void m1(){ try { System.out.println("申请...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
springboot中事务管理@Transactional的注意事项与使用场景
08-26
SpringBoot 中事务管理 @Transactional 的注意事项与使用场景 在本篇文章中，我们将详细讲解 SpringBoot 中事务管理 @Transactional 的注意事项与使用场景，以帮助开发者更好地理解和使用 @Transactional 注解。 ...
举例说明Java多线程编程中读写锁的使用
09-02
使用读写锁的注意事项： - **锁降级**：在某些情况下，线程可能需要在拥有写锁的状态下转换为读锁，如示例中的`processCachedData()`方法所示。这是一个高级用法，用于优化性能，因为写锁到读锁的降级可以避免其他...
java堆栈类使用实例(java中stack的使用方法)
09-04
4. **注意事项**： - Stack类是线程安全的，这意味着在多线程环境下可以同时使用，而无需额外的同步措施。但在性能要求较高的情况下，可能需要考虑使用非同步的替代品，如`Deque`接口的实现，如`ArrayDeque`。 - ...
Java 锁的使用
KEEP CODING
03-13 797
悲观锁：总是假设最坏的情况，认为共享资源每次被访问的时候就会出现问题（比如共享数据被修改），所以每次在获取资源操作的时候都会上锁。 乐观锁：总是假设最好的情况，认为共享资源每次访问的时候不会出现问题，线程可以不停执行，无需加锁，只是在提交修改的时候去验证对应的资源是否被其他线程修改了。
Java锁的基本用法
daijianzhou的专栏
05-18 2568
文章目录Java锁的基本用法synchronized和locksynchronized首先在没有加锁的情况下加锁的情况Lock首先在没有加锁的情况下加锁的情况下线程的通信synchronized 通过wait和notifyAll进行通信synchronized 需求唤醒问题使用Lock定向唤醒线程 Java锁的基本用法 synchronized和lock synchronized synchronized是方法锁，可自动加锁和释放锁，因为其是方法级锁，也就是说将锁定整个方法的内容，所以对于业务逻辑较为复杂的
java 读锁有什么用_锁的使用_java
weixin_32081953的博客
02-25 222
LockLock是一个接口，在Lock中声明了五个方法。lock()lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。tryLock()tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败(即锁已被其他线程获取)，则返回false，也就说这个方法无论如何都会立即返回。tryLock(longtime, T...
java中锁的使用经验
weixin_38738049的博客
01-25 406
java 锁 锁竞争 面试
java 中的锁不要乱用
大东码字
02-14 147
是一种有效的同步机制，它可以帮助开发者控制多线程访问共享资源的安全性。但是，如果不正确使用，它可能会导等问题。因此，使用锁时要格外小心，不要乱用。
Java 基础之锁
禽兽先生不禽兽
12-04 500
上一篇博客中记录了线程的一些概念，那多线程既然能与人方便必然也会带来一些问题，这些问题主要与线程的三大特性有关，Java 的一些关键字和锁机制，可以帮助我们解决这些问题。
java线程锁的基本使用详解
最新发布
weixin_39565641的博客
08-04 539
Lock、ReentrantLock、 ReadWriteLock、ReentrantReadWriteLock、CountDownLatch
java中锁的详解
清雨小竹
05-26 2426
因此，重量级锁的开销较大，可能会导致线程阻塞和性能下降。但是，由于重量级锁提供了最高的线程安全性，所以在需要确保数据完整性和一致性的情况下，重量级锁是非常有用的。但是，由于轻量级锁不是互斥的，所以如果多个线程同时尝试获取锁，则可能导致数据不一致的问题。可重入锁(Reentrant Lock):可重入锁允许同一个线程多次获取同一个锁，这意味着线程可以在执行完同步代码后再次获取该锁而不需要重新竞争。自旋锁(Spin Lock):自旋锁是一种基于忙等待的同步机制，它在获取锁时会一直循环等待，直到获取到锁为止。
Java学习(十八)-锁的使用
qianwenjun_19930314的博客
12-07 384
一、锁类别 1、悲观锁(synchronize) Java 中的重量级锁 synchronize 数据库行锁 2、乐观锁 Java 中的轻量级锁 volatile 和 CAS 数据库版本号–常用 3、分布式锁(Redis锁)–常用 二、实际案例 库存扣减的案例，商品库存100，操作1扣减100，操作2扣减100，如何避免操作1和操作2并发时都成功造成的超卖 方案1：同步排它锁(synchronize)。但是排他锁的缺点很明显： 线程串行导致的性能问题，性能消耗比较大。这种读写都是需要串行么？？ 无
java项目中锁的使用
06-08
在Java项目中，锁的使用可以保证数据同步和线程安全。Java中的锁包括synchronized、ReentrantLock、ReadWriteLock等。下面是使用锁的一些注意事项： 1. 对于需要保证线程安全的方法或代码块，可以使用synchronized关键字来加锁，例如： ``` public synchronized void method() { // 线程安全的代码 } ``` 2. 对于需要更细粒度的锁控制，可以使用ReentrantLock类。需要注意的是，使用完锁后必须释放锁，否则会导致死锁等问题。 ``` ReentrantLock lock = new ReentrantLock(); try { lock.lock(); // 线程安全的代码 } finally { lock.unlock(); } ``` 3. 在高并发场景下，使用ReadWriteLock可以提高性能。读锁可以被多个线程同时获取，而写锁只能被一个线程获取。 ``` ReadWriteLock lock = new ReentrantReadWriteLock(); lock.readLock().lock(); try { // 读操作 } finally { lock.readLock().unlock(); } lock.writeLock().lock(); try { // 写操作 } finally { lock.writeLock().unlock(); } ``` 4. 在使用锁时，应该避免锁的粒度过大或过小。过大的锁粒度会导致并发性能下降，而过小的锁粒度会导致锁争用，也会影响性能。 5. 使用锁时，应该避免死锁和活锁等问题。在设计代码时，应该考虑到所有可能的情况，避免出现死锁和活锁等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值