Java线程新同步机制

最新推荐文章于 2024-09-15 19:46:31 发布

fengg5241

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量526

点赞数

分类专栏： java 文章标签： java action signal string nested 测试

java 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

Java线程新的同步机制

1. 可重入锁ReentrantLock，相当于synchronized块，为临界区提供互斥访问机制.

(1). 相关的接口

创建一个可重入锁
Lock lock = new ReentrantLock();

请求锁,如果锁被当前另一个线程持有，则阻塞。
void lock()

释放锁
void unlock();

非阻塞型lock()
boolean tryLock();

(2). 使用基本结构
   locker.lock();

   try{

     //code here to access the cirtical section
   }finally{
locker.unlock();
   }

   这种结构保证在任何时刻只有一个线程能够进入临界区，如果一个线程锁住了锁对象，其他任何线程在调用lock时，都会被阻塞，直到第一个线程释放锁对象。而且无论try块是否抛出异常，都会执行finally block,解锁locker.

(3). 锁的可重入性:锁是可重入的，线程能够重复地获取它已经拥有的锁。锁对象维护一个持有计数(hold count)来追踪对lock方法的嵌套调用。线程在每次调用lock后都要调用unlock来释放锁。由于这个特性，被一个锁保护的代码可以调用另一个使用相同锁的方法。

(4). 示例代码:

Java代码

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class WorkerOne extends Thread{
private Lock locker;
public WorkerOne (Lock locker){
this.locker = locker;
}
public void run(){
locker.lock();
try{
System.out.println(Thread.currentThread().getName()+":step into critical section");
}finally{
locker.unlock();
}
}
}
class WorkerTwo extends Thread{
private Lock locker;
public WorkerTwo (Lock locker){
this.locker = locker;
}
public void sayHello(){
locker.lock();
try{
System.out.println(Thread.currentThread().getName()+":call sayHello()");
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
locker.unlock();
}
}
public void run(){
locker.lock();
try{
System.out.println(Thread.currentThread().getName()+":setp into critical section");
//测试锁的可重入性
sayHello();
}finally{
locker.unlock();
}
}
}
public class Test5 {
public static void main(String[] args) {
Lock locker = new ReentrantLock();
WorkerOne wo= new WorkerOne(locker);
wo.setName("WorkerOne");
WorkerTwo wt = new WorkerTwo(locker);
wt.setName("WorkerTwo");
wt.start();
wo.start();
}
}

输出:
WorkerTwo:setp into critical section
WorkerTwo:call sayHello()
WorkerOne:step into critical section

2.条件对象Condition,相当于wait-notify机制，提供一种线程间的等待通知机制,condition中的等待-通知方法是await(),signal

(),signalAll(),也需要在互斥环境下被调用。

(1) 相关的接口

创建Condition对象,Condition对象是跟Lock关联在一起的.
Lock locker = new ReentrantLock();
Condition cond = locker.newCondition();

把此线程放到条件的等待集中。
void await();

解除此条件的等待集中所有线程的阻塞状态
void signalAll();

在此条件的等待集中随机选择一个线程，解除其阻塞状态。
void signal();

(2). 使用的基本结构

Java代码

//初始时ok_to_proceed为false.
locker.lock()
try{
while(!ok_to_proceed){
//进入等待此条件集中,被阻塞,它维持状态直到另一个线程调用同一个条件上的
//signalAll/signal方法时为止。
cond.await();
}
}finally{
cker.unlock();
}

Java代码

locker.lock();
try{
//调用将解除所有等待此条件下的线程的阻塞状态。当线程从等待集中被移走时，它们将再次成为可运行的，调度器将再次激活它们
//此时，它们将试图重新进入对象。一旦锁可获得，它们中的某个线程将从await调用返回，从而获得锁并从它被阻塞的地方继续执行。
ok_to_proceed = true;
cond.signalAll() or cond.signal();
}finally{
locker.unlock();
}

ok_to_proceed也是为了防止wait-notify出现的问题，即再wait之间，notify()已经给出通知，此时wait只会一直等待下去,这样就保证了signal()线程的通知被await()线程接收到。

(3) 测试代码:

Java代码

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class GlobalV{
public final static Lock locker = new ReentrantLock();
public final static Condition cond = locker.newCondition();
public static boolean to_proceed = false;
}
class Response extends Thread{
public void run(){
while(true){
GlobalV.locker.lock();
try{
while(!GlobalV.to_proceed){
GlobalV.cond.await();
}
System.out.println("Response:finish a job");
GlobalV.to_proceed = false;
}catch(Exception e){
e.printStackTrace();
}finally{
GlobalV.locker.unlock();
}
}
}
}
class Request extends Thread{
public void run(){
while(true){
GlobalV.locker.lock();
try{
GlobalV.to_proceed = true;
GlobalV.cond.signalAll();
System.out.println("Request:send a job to Response");
}finally{
GlobalV.locker.unlock();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test6 {
public static void main(String[] args) {
Request req = new Request();
Response res = new Response();
req.start();
res.start();
}
}

输出:
Request:send a job to Response
Response:finish a job
Request:send a job to Response
Response:finish a job
Request:send a job to Response
Response:finish a job
Request:send a job to Response
Response:finish a job

3. 读写锁ReentrantReadWriteLock,适用于"读多写少"的多线程应用场景，"读-写"互斥，"写-写"互斥，而读-读可以共享同读锁，即一个线程获取读锁，其它线程可直接进入读，不会被阻塞。

(1). 相关接口

    创建读写锁对象
    ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

    获取读锁
    Lock readLock = rwLock.readLock();

    获取写锁
    Lock writeLock = rwLock.writeLock();

(2). 读写锁使用基本结构

   //对所有的读操作添加读锁

Java代码

readLock.lock();
try{
//code to read
}finally{
readLock.unlock();
}

//对所有的写操作添加写锁

Java代码

writeLock.lock();
try{
//code to write
}finally{
writeLock.unlock();
}

(3). 测试代码:

Java代码

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class Reader extends Thread {
private Lock readLock = null;
public Reader(Lock readLock) {
this.readLock = readLock;
}
public void run() {
while (true) {
readLock.lock();
try {
System.out.println(Thread.currentThread().getName()
+ ":read action for 1 seconds-"+ReadWriteLock.testVal);
} finally {
readLock.unlock();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class Writer extends Thread {
private Lock writeLock = null;
public Writer(Lock writeLock) {
this.writeLock = writeLock;
}
public void run() {
while (true) {
writeLock.lock();
try {
System.out.println(Thread.currentThread().getName()
+ ":write action for 2 seconds");
if(ReadWriteLock.testVal.equals("1111"))
ReadWriteLock.testVal = "2222";
else
ReadWriteLock.testVal = "1111";
} finally {
writeLock.unlock();
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class ReadWriteLock {
public static String testVal = "Initiation";
public static void main(String[] args) {
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
Lock readLock = lock.readLock();
Lock writeLock = lock.writeLock();
Reader reader1 = new Reader(readLock);
reader1.setName("reader1");
Reader reader2 = new Reader(readLock);
reader2.setName("reader2");
Reader reader3 = new Reader(readLock);
reader3.setName("reader3");
Reader reader4 = new Reader(readLock);
reader4.setName("reader4");
Writer writer = new Writer(writeLock);
writer.setName("writer1");
reader1.start();
reader2.start();
reader3.start();
reader4.start();
writer.start();
}
}

输出:
reader1:read action for 1 seconds-Initiation
reader3:read action for 1 seconds-Initiation
writer1:write action for 2 seconds
reader2:read action for 1 seconds-1111
reader4:read action for 1 seconds-1111
reader3:read action for 1 seconds-1111
reader1:read action for 1 seconds-1111
reader4:read action for 1 seconds-1111
reader2:read action for 1 seconds-1111
writer1:write action for 2 seconds
reader4:read action for 1 seconds-2222
reader1:read action for 1 seconds-2222
reader3:read action for 1 seconds-2222
reader2:read action for 1 seconds-2222

4. 总结

(1). Lock接口替代synchronized
     Lock接口可以比sychronized提供更广泛的锁定操作.可以提供多把不同的锁.且锁之间互不干涉.
     Lock接口提供lock()与unlock()方法, 使用明确调用来完成同步的, OO思想好于前者.
     Lock可以自由操控同步范围(scope).
     Lock接口支持nested lock(嵌套锁定).并提供了丰富的api.
     Lock接口提供了tryLock()方法, 支持尝试取得某个object lock.