Java自学-多线程 Lock对象
多线程 Lock对象
与synchronized相似的，lock也可以达到同步的效果html
步骤 1 : 回忆 synchronized 同步的方式java
首先回忆一下 synchronized 同步对象的方式多线程
当一个线程占用 synchronized 同步对象，其余线程就不能占用了，直到释放这个同步对象为止this
package multiplethread;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestThread {
public static String now(){
return new SimpleDateFormat("HH:mm:ss").format(new Date());
}
public static void main(String[] args) {
final Object someObject = new Object();
Thread t1 = new Thread(){
public void run(){
try {
System.out.println( now()+" t1 线程已经运行");
System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
synchronized (someObject) {
System.out.println( now()+this.getName()+ " 占有对象：someObject");
Thread.sleep(5000);
System.out.println( now()+this.getName()+ " 释放对象：someObject");
}
System.out.println(now()+" t1 线程结束");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
t1.setName(" t1");
t1.start();
Thread t2 = new Thread(){
public void run(){
try {
System.out.println( now()+" t2 线程已经运行");
System.out.println( now()+this.getName()+ " 试图占有对象：someObject");
synchronized (someObject) {
System.out.println( now()+this.getName()+ " 占有对象：someObject");
Thread.sleep(5000);
System.out.println( now()+this.getName()+ " 释放对象：someObject");
}
System.out.println(now()+" t2 线程结束");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
};
t2.setName(" t2");
t2.start();
}
}
步骤 2 : 使用Lock对象实现同步效果spa
Lock是一个接口，为了使用一个Lock对象，须要用到线程
Lock lock = new ReentrantLock();
与 synchronized (someObject) 相似的，lock()方法，表示当前线程占用lock对象，一旦占用，其余线程就不能占用了。 与 synchronized 不一样的是，一旦synchronized 块结束，就会自动释放对someObject的占用。 lock却必须调用unlock方法进行手动释放，为了保证释放的执行，每每会把unlock() 放在finally中进行。设计
package multiplethread;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestThread {
public static String now() {
return new SimpleDateFormat("HH:mm:ss").format(new Date());
}
public static void log(String msg) {
System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
}
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Thread t1 = new Thread() {
public void run() {
try {
log("线程启动");
log("试图占有对象：lock");
lock.lock();
log("占有对象：lock");
log("进行5秒的业务操做");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log("释放对象：lock");
lock.unlock();
}
log("线程结束");
}
};
t1.setName("t1");
t1.start();
try {
//先让t1飞2秒
Thread.sleep(2000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
Thread t2 = new Thread() {
public void run() {
try {
log("线程启动");
log("试图占有对象：lock");
lock.lock();
log("占有对象：lock");
log("进行5秒的业务操做");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log("释放对象：lock");
lock.unlock();
}
log("线程结束");
}
};
t2.setName("t2");
t2.start();
}
}
步骤 3 : trylock方法code
synchronized 是不占用到手不罢休的，会一直试图占用下去。 与 synchronized 的钻牛角尖不同，Lock接口还提供了一个trylock方法。 trylock会在指定时间范围内试图占用，占成功了，就啪啪啪。 若是时间到了，还占用不成功，扭头就走~orm
注意： 由于使用trylock有可能成功，有可能失败，因此后面unlock释放锁的时候，须要判断是否占用成功了，若是没占用成功也unlock,就会抛出异常htm
package multiplethread;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestThread {
public static String now() {
return new SimpleDateFormat("HH:mm:ss").format(new Date());
}
public static void log(String msg) {
System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
}
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Thread t1 = new Thread() {
public void run() {
boolean locked = false;
try {
log("线程启动");
log("试图占有对象：lock");
locked = lock.tryLock(1,TimeUnit.SECONDS);
if(locked){
log("占有对象：lock");
log("进行5秒的业务操做");
Thread.sleep(5000);
}
else{
log("通过1秒钟的努力，尚未占有对象，放弃占有");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(locked){
log("释放对象：lock");
lock.unlock();
}
}
log("线程结束");
}
};
t1.setName("t1");
t1.start();
try {
//先让t1飞2秒
Thread.sleep(2000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
Thread t2 = new Thread() {
public void run() {
boolean locked = false;
try {
log("线程启动");
log("试图占有对象：lock");
locked = lock.tryLock(1,TimeUnit.SECONDS);
if(locked){
log("占有对象：lock");
log("进行5秒的业务操做");
Thread.sleep(5000);
}
else{
log("通过1秒钟的努力，尚未占有对象，放弃占有");
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(locked){
log("释放对象：lock");
lock.unlock();
}
}
log("线程结束");
}
};
t2.setName("t2");
t2.start();
}
}
步骤 4 : 线程交互
使用synchronized方式进行线程交互，用到的是同步对象的wait,notify和notifyAll方法
Lock也提供了相似的解决办法，首先经过lock对象获得一个Condition对象，而后分别调用这个Condition对象的：await, signal,signalAll 方法
注意： 不是Condition对象的wait,nofity,notifyAll方法,是await,signal,signalAll
package multiplethread;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestThread {
public static String now() {
return new SimpleDateFormat("HH:mm:ss").format(new Date());
}
public static void log(String msg) {
System.out.printf("%s %s %s %n", now() , Thread.currentThread().getName() , msg);
}
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Thread t1 = new Thread() {
public void run() {
try {
log("线程启动");
log("试图占有对象：lock");
lock.lock();
log("占有对象：lock");
log("进行5秒的业务操做");
Thread.sleep(5000);
log("临时释放对象 lock， 并等待");
condition.await();
log("从新占有对象 lock，并进行5秒的业务操做");
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log("释放对象：lock");
lock.unlock();
}
log("线程结束");
}
};
t1.setName("t1");
t1.start();
try {
//先让t1飞2秒
Thread.sleep(2000);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
Thread t2 = new Thread() {
public void run() {
try {
log("线程启动");
log("试图占有对象：lock");
lock.lock();
log("占有对象：lock");
log("进行5秒的业务操做");
Thread.sleep(5000);
log("唤醒等待中的线程");
condition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
log("释放对象：lock");
lock.unlock();
}
log("线程结束");
}
};
t2.setName("t2");
t2.start();
}
}
步骤 5 : 总结Lock和synchronized的区别
-
Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现，Lock是代码层面的实现。
-
Lock能够选择性的获取锁，若是一段时间获取不到，能够放弃。synchronized不行，会一根筋一直获取下去。 借助Lock的这个特性，就可以规避死锁，synchronized必须经过谨慎和良好的设计，才能减小死锁的发生。
-
synchronized在发生异常和同步块结束的时候，会自动释放锁。而Lock必须手动释放， 因此若是忘记了释放锁，同样会形成死锁。
练习： 多线程 Lock对象
当多个线程按照不一样顺序占用多个同步对象的时候，就有可能产生死锁现象。
死锁之因此会发生，就是由于synchronized 若是占用不到同步对象，就会苦苦的一直等待下去，借助tryLock的有限等待时间，解决死锁问题
答案 :
package multiplethread;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestThread {
public static void main(String[] args) throws InterruptedException {
Lock lock_ahri = new ReentrantLock();
Lock lock_annie = new ReentrantLock();
Thread t1 = new Thread() {
public void run() {
// 占有九尾妖狐
boolean ahriLocked = false;
boolean annieLocked = false;
try {
ahriLocked = lock_ahri.tryLock(10, TimeUnit.SECONDS);
if (ahriLocked) {
System.out.println("t1 已占有九尾妖狐");
// 停顿1000秒，另外一个线程有足够的时间占有安妮
Thread.sleep(1000);
System.out.println("t1 试图在10秒内占有安妮");
try {
annieLocked = lock_annie.tryLock(10, TimeUnit.SECONDS);
if (annieLocked)
System.out.println("t1 成功占有安妮，开始啪啪啪");
else{
System.out.println("t1 总是占用不了安妮，放弃");
}
} finally {
if (annieLocked){
System.out.println("t1 释放安妮");
lock_annie.unlock();
}
}
}
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} finally {
if (ahriLocked){
System.out.println("t1 释放九尾狐");
lock_ahri.unlock();
}
}
}
};
t1.start();
Thread.sleep(100);
Thread t2 = new Thread() {
public void run() {
boolean annieLocked = false;
boolean ahriLocked = false;
try {annieLocked = lock_annie.tryLock(10, TimeUnit.SECONDS);
if (annieLocked){
System.out.println("t2 已占有安妮");
// 停顿1000秒，另外一个线程有足够的时间占有安妮
Thread.sleep(1000);
System.out.println("t2 试图在10秒内占有九尾妖狐");
try {
ahriLocked = lock_ahri.tryLock(10, TimeUnit.SECONDS);
if (ahriLocked)
System.out.println("t2 成功占有九尾妖狐，开始啪啪啪");
else{
System.out.println("t2 总是占用不了九尾妖狐，放弃");
}
}
finally {
if (ahriLocked){
System.out.println("t2 释放九尾狐");
lock_ahri.unlock();
}
}
}
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} finally {
if (annieLocked){
System.out.println("t2 释放安妮");
lock_annie.unlock();
}
}
}
};
t2.start();
}
}
相关文章
- 1. 多线程 Lock对象
- 2. Java多线程探究-Lock锁对象
- 3. Java™ 教程（Lock对象）
- 4. Java多线程探究-Lock对象锁条件变量
- 5. Java多线程(9)：Lock
- 6. 多线程-Lock
- 7. Python线程专题4:Timer对象、Lock对象、Rlock对象
- 8. java自学讲义 多线程
- 9. Java线程-Lock学习（五）
- 10. Java多线程：Java多线程同步与对象控制权
- 更多相关文章...
- • C# 多线程 - C#教程
- • 多对多关联查询 - MyBatis教程
- • 适用于PHP初学者的学习线路和建议
- • Java 8 Stream 教程
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章