锁对象Lock-同步问题更完美的处理方式

最新推荐文章于 2022-03-27 20:42:06 发布
最新推荐文章于 2022-03-27 20:42:06 发布
阅读量831 收藏
点赞数
分类专栏： java
Lock是 java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下：

[java] view plain copy print ?
  1. public class LockTest { 
  2.     public static void main(String[] args) { 
  3.         final Outputter1 output = new Outputter1(); 
  4.         new Thread() { 
  5.             public void run() { 
  6.                 output.output("zhangsan"); 
  7.             }; 
  8.         }.start();       
  9.         new Thread() { 
  10.             public void run() { 
  11.                 output.output("lisi"); 
  12.             }; 
  13.         }.start(); 
  14.     } 
  15. } 
  16. class Outputter1 { 
  17.     private Lock lock = new ReentrantLock();// 锁对象 
  18.     public void output(String name) { 
  19.         // TODO 线程输出方法 
  20.         lock.lock();// 得到锁 
  21.         try { 
  22.             for(int i = 0; i < name.length(); i++) { 
  23.                 System.out.print(name.charAt(i)); 
  24.             } 
  25.         } finally { 
  26.             lock.unlock();// 释放锁 
  27.         } 
  28.     } 
  29. }  
public class LockTest {
	public static void main(String[] args) {
		final Outputter1 output = new Outputter1();
		new Thread() {
			public void run() {
				output.output("zhangsan");
			};
		}.start();		
		new Thread() {
			public void run() {
				output.output("lisi");
			};
		}.start();
	}
}
class Outputter1 {
	private Lock lock = new ReentrantLock();// 锁对象
	public void output(String name) {
		// TODO 线程输出方法
		lock.lock();// 得到锁
		try {
			for(int i = 0; i < name.length(); i++) {
				System.out.print(name.charAt(i));
			}
		} finally {
			lock.unlock();// 释放锁
		}
	}
}
        这样就实现了和sychronized一样的同步效果，需要注意的是，用sychronized修饰的方法或者语句块在代码执行完之后锁自动释放，而是用Lock需要我们手动释放锁，所以为了保证锁最终被释放(发生异常情况)，要把互斥区放在try内，释放锁放在finally内。

        如果说这就是Lock，那么它不能成为同步问题更完美的处理方式，下面要介绍的是读写锁(ReadWriteLock)，我们会有一种需求，在对数据进行读写的时候，为了保证数据的一致性和完整性，需要读和写是互斥的，写和写是互斥的，但是读和读是不需要互斥的，这样读和读不互斥性能更高些，来看一下不考虑互斥情况的代码原型：

[java] view plain copy print ?
  1. public class ReadWriteLockTest { 
  2.     public static void main(String[] args) { 
  3.         final Data data = new Data(); 
  4.         for (int i = 0; i < 3; i++) { 
  5.             new Thread(new Runnable() { 
  6.                 public void run() { 
  7.                     for (int j = 0; j < 5; j++) { 
  8.                         data.set(new Random().nextInt(30)); 
  9.                     } 
  10.                 } 
  11.             }).start(); 
  12.         }        
  13.         for (int i = 0; i < 3; i++) { 
  14.             new Thread(new Runnable() { 
  15.                 public void run() { 
  16.                     for (int j = 0; j < 5; j++) { 
  17.                         data.get(); 
  18.                     } 
  19.                 } 
  20.             }).start(); 
  21.         } 
  22.     } 
  23. } 
  24. class Data {     
  25.     private int data;// 共享数据     
  26.     public void set(int data) { 
  27.         System.out.println(Thread.currentThread().getName() + "准备写入数据"); 
  28.         try { 
  29.             Thread.sleep(20); 
  30.         } catch (InterruptedException e) { 
  31.             e.printStackTrace(); 
  32.         } 
  33.         this.data = data; 
  34.         System.out.println(Thread.currentThread().getName() + "写入" + this.data); 
  35.     }    
  36.     public void get() { 
  37.         System.out.println(Thread.currentThread().getName() + "准备读取数据"); 
  38.         try { 
  39.             Thread.sleep(20); 
  40.         } catch (InterruptedException e) { 
  41.             e.printStackTrace(); 
  42.         } 
  43.         System.out.println(Thread.currentThread().getName() + "读取" + this.data); 
  44.     } 
  45. }  
public class ReadWriteLockTest {
	public static void main(String[] args) {
		final Data data = new Data();
		for (int i = 0; i < 3; i++) {
			new Thread(new Runnable() {
				public void run() {
					for (int j = 0; j < 5; j++) {
						data.set(new Random().nextInt(30));
					}
				}
			}).start();
		}		
		for (int i = 0; i < 3; i++) {
			new Thread(new Runnable() {
				public void run() {
					for (int j = 0; j < 5; j++) {
						data.get();
					}
				}
			}).start();
		}
	}
}
class Data {	
	private int data;// 共享数据	
	public void set(int data) {
		System.out.println(Thread.currentThread().getName() + "准备写入数据");
		try {
			Thread.sleep(20);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		this.data = data;
		System.out.println(Thread.currentThread().getName() + "写入" + this.data);
	}	
	public void get() {
		System.out.println(Thread.currentThread().getName() + "准备读取数据");
		try {
			Thread.sleep(20);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(Thread.currentThread().getName() + "读取" + this.data);
	}
}
        部分输出结果：

[java] view plain copy print ?
  1. Thread-1准备写入数据 
  2. Thread-3准备读取数据 
  3. Thread-2准备写入数据 
  4. Thread-0准备写入数据 
  5. Thread-4准备读取数据 
  6. Thread-5准备读取数据 
  7. Thread-2写入12 
  8. Thread-4读取12 
  9. Thread-5读取5 
  10. Thread-1写入12  
Thread-1准备写入数据
Thread-3准备读取数据
Thread-2准备写入数据
Thread-0准备写入数据
Thread-4准备读取数据
Thread-5准备读取数据
Thread-2写入12
Thread-4读取12
Thread-5读取5
Thread-1写入12
        我们要实现写入和写入互斥，读取和写入互斥，读取和读取互斥，在set和get方法加入sychronized修饰符：

[java] view plain copy print ?
  1. public synchronized void set(int data) {...}     
  2. public synchronized void get() {...}  
public synchronized void set(int data) {...}	
public synchronized void get() {...}
        部分输出结果：
[java] view plain copy print ?
  1. Thread-0准备写入数据 
  2. Thread-0写入9 
  3. Thread-5准备读取数据 
  4. Thread-5读取9 
  5. Thread-5准备读取数据 
  6. Thread-5读取9 
  7. Thread-5准备读取数据 
  8. Thread-5读取9 
  9. Thread-5准备读取数据 
  10. Thread-5读取9  
Thread-0准备写入数据
Thread-0写入9
Thread-5准备读取数据
Thread-5读取9
Thread-5准备读取数据
Thread-5读取9
Thread-5准备读取数据
Thread-5读取9
Thread-5准备读取数据
Thread-5读取9
        我们发现，虽然写入和写入互斥了，读取和写入也互斥了，但是读取和读取之间也互斥了，不能并发执行，效率较低，用读写锁实现代码如下：

[java] view plain copy print ?
  1. class Data {     
  2.     private int data;// 共享数据 
  3.     private ReadWriteLock rwl = new ReentrantReadWriteLock();    
  4.     public void set(int data) { 
  5.         rwl.writeLock().lock();// 取到写锁 
  6.         try { 
  7.             System.out.println(Thread.currentThread().getName() + "准备写入数据"); 
  8.             try { 
  9.                 Thread.sleep(20); 
  10.             } catch (InterruptedException e) { 
  11.                 e.printStackTrace(); 
  12.             } 
  13.             this.data = data; 
  14.             System.out.println(Thread.currentThread().getName() + "写入" + this.data); 
  15.         } finally { 
  16.             rwl.writeLock().unlock();// 释放写锁 
  17.         } 
  18.     }    
  19.     public void get() { 
  20.         rwl.readLock().lock();// 取到读锁 
  21.         try { 
  22.             System.out.println(Thread.currentThread().getName() + "准备读取数据"); 
  23.             try { 
  24.                 Thread.sleep(20); 
  25.             } catch (InterruptedException e) { 
  26.                 e.printStackTrace(); 
  27.             } 
  28.             System.out.println(Thread.currentThread().getName() + "读取" + this.data); 
  29.         } finally { 
  30.             rwl.readLock().unlock();// 释放读锁 
  31.         } 
  32.     } 
  33. }  
class Data {	
	private int data;// 共享数据
	private ReadWriteLock rwl = new ReentrantReadWriteLock();	
	public void set(int data) {
		rwl.writeLock().lock();// 取到写锁
		try {
			System.out.println(Thread.currentThread().getName() + "准备写入数据");
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			this.data = data;
			System.out.println(Thread.currentThread().getName() + "写入" + this.data);
		} finally {
			rwl.writeLock().unlock();// 释放写锁
		}
	}	
	public void get() {
		rwl.readLock().lock();// 取到读锁
		try {
			System.out.println(Thread.currentThread().getName() + "准备读取数据");
			try {
				Thread.sleep(20);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "读取" + this.data);
		} finally {
			rwl.readLock().unlock();// 释放读锁
		}
	}
}

        部分输出结果：

[java] view plain copy print ?
  1. Thread-4准备读取数据 
  2. Thread-3准备读取数据 
  3. Thread-5准备读取数据 
  4. Thread-5读取18 
  5. Thread-4读取18 
  6. Thread-3读取18 
  7. Thread-2准备写入数据 
  8. Thread-2写入6 
  9. Thread-2准备写入数据 
  10. Thread-2写入10 
  11. Thread-1准备写入数据 
  12. Thread-1写入22 
  13. Thread-5准备读取数据  
Thread-4准备读取数据
Thread-3准备读取数据
Thread-5准备读取数据
Thread-5读取18
Thread-4读取18
Thread-3读取18
Thread-2准备写入数据
Thread-2写入6
Thread-2准备写入数据
Thread-2写入10
Thread-1准备写入数据
Thread-1写入22
Thread-5准备读取数据

        从结果可以看出实现了我们的需求，这只是锁的基本用法，锁的机制还需要继续深入学习。

USTCZYY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程(八)：锁对象Lock-同步问题更完美的处理方式
m0_70083038的博客
04-28 212
new Thread() { public void run() { output.output(“zhangsan”); }; }.start(); new Thread() { public void run() { output.output(“lisi”); }; }.start(); } } class Outputter1 {..
synchronized 方法锁 对象锁 类锁
dycy的博客
09-27 1508
synchronized 方法锁 对象锁 类锁方法锁对象锁类锁 方法锁 synchronized修饰方法时 每个类的实例类的实例对应一把锁（方法锁也是对象锁） 执行synchronized修饰的方法必须拥有实例对象的锁 方法一旦执行，就会独占该锁，方法执行完毕，会释放该锁 其他没获得锁的线程处于阻塞状态 不加synchronized： 对象锁 synchronized修饰对象或代码块 java的每个对象都有一个互斥锁，线程运行synchronized修饰的方法或代码块时都要获得这个对象的锁 没
14.Lock锁
weixin_56121715的博客
03-27 318
笔记
线程同步Synchronized，监视器monitor和锁lock的关系3---马克-to-win java视频
06-10
线程同步Synchronized，监视器monitor和锁lock的关系2---马克-to-win java视频
Java多线程学习（六）Lock锁的使用
weixin_34214500的博客
03-27 1633
系列文章传送门: Java多线程学习（一）Java多线程入门 Java多线程学习（二）synchronized关键字（1） Java多线程学习（二）synchronized关键字（2） Java多线程学习（三）volatile关键字 Java多线程学习（四）等待/通知（wait/notify）机制 Java多线程学习（五）线程间通信知识点补充 系列文章将被优先更新于微信公众号“Java面试通关手册...
java synchronized关键字的用法
ws_zhh的专栏
11-03 2930
在java编程中，经常需要用到同步，而用得最多的也许是synchronized关键字了，下面看看这个关键字的用法。 因为synchronized关键字涉及到锁的概念，所以先来了解一些相关的锁知识。   java的内置锁：每个java对象都可以用做一个实现同步的锁，这些锁成为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入...
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例
08-28
Java线程之锁对象Lock-同步问题更完美的处理方式代码实例 Java中的锁对象Lock是java.util.concurrent.locks包下的接口，提供了比使用synchronized方法和语句可获得的更广泛的锁定操作。它能以更优雅的方式处理线程...
完美解决Java中的线程安全问题
08-29
解决线程安全问题的方法有多种，包括使用 synchronized 关键字、Lock 对象、Atomic 变量等。今天，我们将讨论使用 synchronized 关键字来解决线程安全问题。 使用 synchronized 关键字可以将需要同步的代码块锁定，...
C#多线程解决界面卡死问题的完美解决方案
02-05
1. `async/await`关键字：这是C#4.5引入的异步编程模型，可以更简洁地处理异步操作。`async`方法返回一个`Task`或`Task<T>`，`await`用于等待任务完成。例如： ```csharp public async Task BackgroundTaskAsync() {...
CSharpt ToJ ava Converter 22.4.20 完美版
04-27
4. **异步编程**：C#的async/await关键字提供了简洁的异步编程方式，Java则使用Future和Callable接口，以及ExecutorService来处理并发任务。 5. **Lambda表达式**：C#和Java都支持lambda表达式，但语法有所不同。C#...
完美世界面试题，JAVA向
03-10
10. 多线程同步的常见方式有：synchronized 关键字、wait/notify 机制、Lock 接口（如 ReentrantLock）、Semaphore 信号量、CountDownLatch 计数器、CyclicBarrier 闭锁等。 四、编程实践题（略，具体实现可参考...
Java并发编程-Lock
aikuangchou2298的博客
03-11 205
一.synchronized的缺陷 synchronized是java中的一个关键字，也就是说是Java语言内置的特性。那么为什么会出现Lock呢？ 在上面一篇文章中，我们了解到如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况： 1）获取锁的线程执行完了...
lock 锁class类对象和实例对象
java 学习路
02-25 691
java thread 线程中 的synchronized关键字 可以放到方法上，也可以修饰对象上 eg： [code="java"] private synchronized void testSyncMethod() { //当线程执行到此处时，它必须获得一个锁，此时锁定的对象是：调用此方法的对象a } private void testSyncMethod() {...
分布式锁超时问题的处理(只是参考，推荐使用redission框架和ZK做分布式锁)
jaryle的专栏
10-12 9396
1、redis分布式锁的基本实现 redis加锁命令： SETNX resource_name my_random_value PX 30000 这个命令的作用是在只有这个key不存在的时候才会设置这个key的值（NX选项的作用），超时时间设为30000毫秒（PX选项的作用） 这个key的值设为“my_random_value”。这个值必须在所有获取锁请求的客户端里保持唯一。 SET...
java lock 对象_Java™ 教程（Lock对象）
weixin_36293680的博客
02-16 282
Lock对象同步代码依赖于简单的可重入锁，这种锁易于使用，但有许多限制，java.util.concurrent.locks包支持更复杂的锁定语法，我们不会详细检查这个包，而是将重点放在其最基本的接口Lock上。Lock对象的工作方式与同步代码使用的隐式锁定非常相似，与隐式锁一样，一次只有一个线程可以拥有一个Lock对象，Lock对象还通过其关联的Condition对象支持wait/notify机...
对象的notify方法的含义和对象锁释放的三种情况
xuqiaobo的博客
05-27 7158
1，notify的含义     （1）notify一次只随机通知一个线程进行唤醒 （2）  在执行了notify方法之后，当前线程不会马上释放该对象锁，呈wait状态的线程也不能马上获得该对象锁， 要等到执行notify方法的线程将程序执行完 ，也就是退出sychronized代码块后，当前线程才会释放锁， 而呈wait状态所在的线程才可以获取该对象锁。 2，对象锁释放的三种情况
Lock Objects 锁对象
luccs624061082的专栏
06-07 166
同步代码依赖一种简单的可重入锁。虽然这种锁很容易使用，但是有许多局限。许多复杂的锁形式是由java.util.concurrent.locks包支持。我们不详细解释这个包，但是了关注它最重要最基本的接口，Lock。 Lock对象的工作机制与用同步代码的隐式锁很相似。作为隐式锁，只有一个线程能一次拥有一个锁对象。所对象也支持wait/notify机制。，通过它们关联的条件对象。 ...
大学生挑战杯-喜树根器官培养和抗癌物质喜树碱生成的研究.rar
最新发布
07-26
大学生挑战杯-喜树根器官培养和抗癌物质喜树碱生成的研究.rar
--lock-tables和--lock-all-tables区别
07-10
在 MySQL 中，`--lock-tables` 和 `--lock-all-tables` 是两个不同的选项，用于备份数据库或导出数据时的锁定行为。 `--lock-tables` 选项是指在备份或导出过程中，MySQL 会对每个表进行锁定，以确保数据的一致性。这意味着其他会话无法修改被锁定的表，直到备份或导出完成。然而，`--lock-tables` 选项只会锁定这些被备份或导出的表，其他未被操作的表仍然可以被修改。 `--lock-all-tables` 选项是指在备份或导出过程中，MySQL 会对所有表进行全局锁定。这意味着其他会话无法修改任何表，直到备份或导出完成。这包括了被备份或导出的表以及其他未被操作的表。 所以，区别在于 `--lock-all-tables` 会锁定所有表，而 `--lock-tables` 只会锁定相关的表。通常情况下，对于大型数据库，使用 `--lock-all-tables` 会导致更长时间的锁定和较高的并发性影响，而 `--lock-tables` 可能更适合小型数据库或只需要锁定部分表的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值