`

Java之多线程之Lock与Condition

阅读更多
Java之多线程之Lock

接上文
在多线程环境中,大部分情况下,使用 synchronized 关键字可以满足需求。
但是其也存在不足。于是 java.util.concurrent.locks 包出现了。


第一篇

背景

在Java中实现线程同步的传统方法是使用synchronized关键字。
虽然它提供了一定的基本同步,但synchronized参数在使用时非常死板。
例如,一个线程只能锁一次。 同步块不提供等待队列的任何机制,
并且在一个线程退出后,任何线程都可以获取锁定。
这可能导致很长一段时间内某些其他线程的资源匮乏。

Java 从 1.5 开始,提供了可重入锁,以提供更大的灵活性同步。


一、概念
可重入锁
ReentrantLock

当某一线程在已经获取到该锁时,可再多次请求获取该锁,而该线程不会被阻塞而造成死锁。
它在线程不知是否已经获取到锁资源的情况下使用,非常有用。
相反,如果一个锁是不可重入的,当你已经获取到该锁资源,然后再次尝试获取该锁资源时,
就会自己把自己给锁住,造成线程死锁,一直阻塞在那里。


说明一:实现了Lock接口的类,都是可重入的。
可重入锁是 java.util.concurrent.locks.Lock 接口的实现之一。
另一个实现是 ReentrantReadWriteLock。

说明二:锁线程的方法介绍
- lock(), 拿不到lock就不罢休,不然线程就一直block。 比较无赖的做法。

- tryLock(),马上返回,拿到lock就返回true,不然返回false。 比较潇洒的做法。   
- 带时间限制的tryLock(),拿不到lock,就等一段时间,超时返回false。比较聪明的做法。

- tryInterruptibly:在锁上等待,直到获取锁,但是会响应中断,
这个方法优先考虑响应中断,而不是响应锁的普通获取或重入获取。


二、代码示例


//Java code to illustrate Reentrant Locks 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

class worker implements Runnable {
    SimpleDateFormat ft = new SimpleDateFormat("hh:mm:ss");
    
    String jobName;
    ReentrantLock re;

    public worker(ReentrantLock rl, String n) {
        re = rl;
        jobName = n;
    }

    public void run() {
        boolean done = false;
        while (!done) {
            // Get lock - for the first time (outer lock)
            boolean ans = re.tryLock();

            // Returns True if lock is free
            if (ans) {
                try {
                    log("task %s - outer lock acquired at %s, Doing outer work - 1.5 s, lockHoldCount: %d", 
                            jobName, ft.format(new Date()), re.getHoldCount());
                    
                    Thread.sleep(1500);

                    // re lock - for the second time (inner lock)
                    // This can happens in other method of other classes.
                    re.lock();
                    try {
                        log("task %s - inner lock acquired at %s, Doing inner work - 1.5 s, lockHoldCount: %d", 
                                jobName, ft.format(new Date()), re.getHoldCount());
                        Thread.sleep(1500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        // Inner lock release
                        re.unlock();
                        
                        log("task %s - releasing inner lock, lockHoldCount: %d", 
                                jobName, re.getHoldCount());
                    }
                    log("task %s - work done", jobName);
                    
                    done = true;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // Outer lock release
                    re.unlock();
                    
                    log("task %s - releasing outer lock, lockHoldCount: %d", 
                            jobName, re.getHoldCount());
                }
            } else {
                log("task %s - waiting for lock - 1 s", jobName);
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    private void log(String pattern, Object... args) {
        System.out.println(String.format(pattern, args));
    }
}

public class ReentrantLockTest {
    static final int MAX_T = 4;

    public static void main(String[] args) {
        ReentrantLock rel = new ReentrantLock();
        ExecutorService pool = Executors.newFixedThreadPool(MAX_T);
        Runnable w1 = new worker(rel, "Job1");
        Runnable w2 = new worker(rel, "Job2");
        Runnable w3 = new worker(rel, "Job3");
        Runnable w4 = new worker(rel, "Job4");
        pool.execute(w1);
        pool.execute(w2);
        pool.execute(w3);
        pool.execute(w4);
        pool.shutdown();
    }
}


/* output:

task Job2 - waiting for lock - 1 s
task Job4 - waiting for lock - 1 s
task Job1 - outer lock acquired at 10:53:27, Doing outer work - 1.5 s, lockHoldCount: 1
task Job3 - waiting for lock - 1 s
task Job4 - waiting for lock - 1 s
task Job2 - waiting for lock - 1 s
task Job3 - waiting for lock - 1 s
task Job1 - inner lock acquired at 10:53:29, Doing inner work - 1.5 s, lockHoldCount: 2
task Job3 - waiting for lock - 1 s
task Job4 - waiting for lock - 1 s
task Job2 - waiting for lock - 1 s
task Job1 - releasing inner lock, lockHoldCount: 1
task Job1 - work done
task Job1 - releasing outer lock, lockHoldCount: 0
task Job3 - waiting for lock - 1 s
task Job4 - waiting for lock - 1 s
task Job2 - outer lock acquired at 10:53:31, Doing outer work - 1.5 s, lockHoldCount: 1
task Job4 - waiting for lock - 1 s
task Job3 - waiting for lock - 1 s
task Job2 - inner lock acquired at 10:53:32, Doing inner work - 1.5 s, lockHoldCount: 2
task Job4 - waiting for lock - 1 s
task Job3 - waiting for lock - 1 s
task Job2 - releasing inner lock, lockHoldCount: 1
task Job2 - work done
task Job2 - releasing outer lock, lockHoldCount: 0
task Job3 - waiting for lock - 1 s
task Job4 - outer lock acquired at 10:53:34, Doing outer work - 1.5 s, lockHoldCount: 1
task Job3 - waiting for lock - 1 s
task Job4 - inner lock acquired at 10:53:35, Doing inner work - 1.5 s, lockHoldCount: 2
task Job3 - waiting for lock - 1 s
task Job4 - releasing inner lock, lockHoldCount: 1
task Job4 - work done
task Job4 - releasing outer lock, lockHoldCount: 0
task Job3 - outer lock acquired at 10:53:37, Doing outer work - 1.5 s, lockHoldCount: 1
task Job3 - inner lock acquired at 10:53:38, Doing inner work - 1.5 s, lockHoldCount: 2
task Job3 - releasing inner lock, lockHoldCount: 1
task Job3 - work done
task Job3 - releasing outer lock, lockHoldCount: 0



*/








第二篇

一、Lock API 的主要类介绍

1、Lock 接口 - 实现类 ReentrantLock
接口类。规定了Lock的基本方法,这些方法可以满足所有 synchronized 的功能,
还提供了更多功能:Lock条件判断、Lock超时判断。

其最主要的方法:
lock():获取锁
unlock():释放锁
tryLock():等待锁一段时间再锁
newCondition():根据条件进行锁

1.1 Condition

背景知识:
- wait()、notify()
在多线程进行协同工作时,需要用到 wait()、notify() 。
wait()、notify() 只能用在 synchronized 块内部,而且是,synchronized 哪个对象,就得调用哪个对象的 wait()、notify() 方法。

Condition 类与Object类的 wait()、notify() 方法功能差不多。
但是提供了更多:可以创建不同的 wait 集合。
Condition 的实例必须由 Lock 类创建,而不是自己去 new 而产生。

主要方法:
await():类似于 Object.wait()
signal():类似于 Object.notify()
signalAll():类似于 Object.notifyAll()



import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.junit.Test;

// 方法一:
// 使用 wait 和 notify 控制线程,
// 使子线程和主线程各交替执行一次。
//=====================================================================

class UseWaitNotify {
	
	private Object dummy = new Object();  
	private boolean flag = true;
	
	public void subThread() {
		synchronized (dummy){
			while(!flag){
				try {
					dummy.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("[UseWaitNotify] sub..");
			flag = false;
			dummy.notify();
		}
	}
	
	public void mainThread(){
		synchronized (dummy){
			while(flag){
				try {
					dummy.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("[UseWaitNotify] main..");
			flag = true;
			dummy.notify();
		}
	}
}

// test method
class WaitNotify{

	@Test
	public void testUseWaitNotify(){
		UseWaitNotify useWaitNotify = new UseWaitNotify();
		new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 0 ; i< 10; i++){
					useWaitNotify.subThread();
				}
			}
		}).start();
			
		
		for(int i = 0 ; i< 10; i++){
			useWaitNotify.mainThread();
		}
		
	}
}


//方法二:
//使用 await 和 signal 控制线程,
//使子线程和主线程各交替执行一次。
//=====================================================================

class UseCondition {
	
	private Lock lock = new ReentrantLock();  
	private Condition condition = lock.newCondition();
	
	private boolean flag = true;
	
	public void subThread(){
		lock.lock();
		try{
			while(!flag){
				try {
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("[UseCondition] sub..");
			flag = false;
			condition.signal();
		}finally{
			lock.unlock();
		}
	}
	
	public void mainThread(){
		lock.lock();
		try{
			while(flag){
				try {
					condition.await();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			System.out.println("[UseCondition] main..");
			flag = true;
			condition.signal();
		}finally{
			lock.unlock();
		}
	}
}

//test method
public class LockCondition {

	@Test
	public void testUseCondition(){
		UseCondition useCondition = new UseCondition();
		new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 0 ; i< 10; i++){
					useCondition.subThread();
				}
			}
		}).start();
			
		
		for(int i = 0 ; i< 10; i++){
			useCondition.mainThread();
		}
		
	}
}








1.2 ReentrantLock
该类被使用的最为广泛。它是在功能上实现了 synchronized 的类。
除了实现了从 Lock 接口继承的方法,它还自己有一些方法:
比如让线程等待一段时间再去获取资源的锁。

什么是 reentrant (可重入)?
其实 synchronized 代码块原本就是可重入(reentrant)的:
例如:
某线程正在执行 synchronized 代码块一,代码块一中需要执行代码块二,
两个代码块锁定的是同一个资源,此时线程一可以顺利执行此两个代码块。
无需重复获取资源的锁,即:资源锁重用。

看下面的例子:
public class Test{

public synchronized foo(){
    //do something
    bar();
  }

  public synchronized bar(){
    //do some more
  }
}

线程在执行 foo()时,需要执行 bar(),此时直接执行即可,无需重复获取锁。
因为这两个 synchronized 代码块锁定的是同一个对象:this


2、ReadWriteLock 接口 - 实现类 ReentrantReadWriteLock
该类包含了一对相互关联的锁。
一种是:只读锁(Read-Only)。如果没有其它线程在占有写锁,该锁可以被多个线程同时拥有。
一种是:写锁。如果没有线程在占有读锁或写锁,该锁只能被一个线程独占。


二、Lock 使用示例

1、先看看用 synchronized 的写法:
public class Resource {
    
    private Object dummy = new Object();
    
    public void doSomething(){
        synchronized(dummy){
            System.out.println("do something...");
        }
    }
    
    public void doLogging(){
        System.out.println("do logging...");
    }

}


2、使用 java.util.concurrent.locks.Lock 的写法:
public class LockResource {
    
    private Lock lock;
    
    public LockResource(){
        this.lock = new ReentrantLock();
    }
    
    public void doSomething(){
        try {
            if(lock.tryLock(10, TimeUnit.SECONDS)){ //时间单位:秒
                System.out.println("do something..");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally{
            lock.unlock(); // release the lock.
        }
    }
    
    public void doLogging(){
        System.out.println("do logging...");
    }

}


3、ReentrantReadWriteLock

class Queue3{
	
	private Object data = null;
	ReadWriteLock lock = new ReentrantReadWriteLock();
	
	/*
	  Read lock: 
	  - make sure no thread is writing.
	 */
	public void get(){
		lock.readLock().lock();
		System.out.println("read data..." + data);
		lock.readLock().unlock();
	}
	
	/*
	  Write lock: 
	  - make sure no thread is writing.
	  - make sure no thread is reading.
	 */
	public void set(Object data){
		lock.writeLock().lock();
		System.out.println("write data...");
		this.data = data;
		lock.writeLock().unlock();
	}
	
}



4. ReentrantReadWriteLock 使用Lock 实现缓存。
 class CachedData {
   Object data;
   volatile boolean cacheValid;
   final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

   void processCachedData() {
     rwl.readLock().lock();
     if (!cacheValid) {
        // Must release read lock before acquiring write lock
        rwl.readLock().unlock();
        rwl.writeLock().lock();
        try {
          // Recheck state because another thread might have
          // acquired write lock and changed state before we did.
          if (!cacheValid) {
            data = ...
            cacheValid = true;
          }
          // Downgrade by acquiring read lock before releasing write lock
          rwl.readLock().lock();
        } finally {
          rwl.writeLock().unlock(); // Unlock write, still hold read
        }
     }

     try {
       use(data);
     } finally {
       rwl.readLock().unlock();
     }
   }
 }





5. 双condition实现的阻塞式消息队列。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 双condition实现的阻塞式消息队列。
 * - 队列满时,不存
 * - 队列空时,不取
 */
public class LockConditionBlockingQueue {

	final Lock lock = new ReentrantLock();
	final Condition notFull = lock.newCondition(); //控制存操作
	final Condition notEmpty = lock.newCondition();//控制取操作

	final Object[] items = new Object[100];
	int putptr, takeptr, count;

	public void put(Object x) throws InterruptedException {
		lock.lock();
		try {
			while (count == items.length)
				notFull.await();
			items[putptr] = x;
			if (++putptr == items.length)
				putptr = 0;
			++count;
			notEmpty.signal();
		} finally {
			lock.unlock();
		}
	}

	public Object take() throws InterruptedException {
		lock.lock();
		try {
			while (count == 0)
				notEmpty.await();
			Object x = items[takeptr];
			if (++takeptr == items.length)
				takeptr = 0;
			--count;
			notFull.signal();
			return x;
		} finally {
			lock.unlock();
		}
	}
}




6. 使用 3 个 condition,使每个子线程各自交替执行。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import org.junit.Test;

public class LockConditionThree {
	final int maxLoop = 100;
	
	@Test
	public void testUseCondition(){
		UseCondition useCondition = new UseCondition();
		new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 0 ; i< maxLoop; i++){
					useCondition.sub1();
				}
			}
		}).start();

		new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 0 ; i< maxLoop; i++){
					useCondition.sub2();
				}
			}
		}).start();
		
		new Thread(new Runnable(){
			@Override
			public void run() {
				for(int i = 0 ; i< maxLoop; i++){
					useCondition.sub3();
				}
			}
		}).start();
	
		
	}
	

	//使用 3 个 condition,使每个子线程各自交替执行。
	//=======================================================

	static class UseCondition {
		
		private Lock lock = new ReentrantLock();  
		private Condition condition1 = lock.newCondition();
		private Condition condition2 = lock.newCondition();
		private Condition condition3 = lock.newCondition();
		
		private int shouldSub = 1;
		
		public void sub1(){
			lock.lock();
			try{
				while(shouldSub != 1){
					try {
						condition1.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("sub1..");
				shouldSub = 2;
				condition2.signal(); //notify thread 2
			}finally{
				lock.unlock();
			}
		}
		
		public void sub2(){
			lock.lock();
			try{
				while(shouldSub != 2){
					try {
						condition2.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("sub2..");
				shouldSub = 3;
				condition3.signal(); //notify thread 3
			}finally{
				lock.unlock();
			}
		}
		public void sub3(){
			lock.lock();
			try{
				while(shouldSub != 3){
					try {
						condition3.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println("sub3..\n");
				shouldSub = 1;
				condition1.signal(); //notify thread 1
			}finally{
				lock.unlock();
			}
		}
	}
}





7. Semaphore
Semaphore可以控制某个资源可被同时访问的个数,通过 acquire() 获取一个许可,如果没有就等待,而 release() 释放一个许可。
比如在Windows下可以设置共享文件的最大客户端访问个数。

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Semaphore;

public class LockSemephore {

	public static void main(String[] args) {

		ExecutorService exec = Executors.newCachedThreadPool();
		final Semaphore semp = new Semaphore(5); // 同时只能5个线程使用

		for (int index = 0; index < 20; index++) { // 模拟20个客户端访问
			final int NO = index;
			exec.execute(new Runnable() {
				public void run() {
					try {
						semp.acquire();// 获取许可
						System.out.println("Accessing: " + NO);
						Thread.sleep(2000);
						semp.release();// 访问完后,释放
						System.out.println("AvailablePermits:---------" + semp.availablePermits());
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
		// 退出线程池
		exec.shutdown();
		System.out.println("done!");
	}

}










java.util.concurrent包之Execuotor系列文章

00_Java之 java.util.concurrent 包之概述

01_Java之java.util.concurrent包之Executor与ExecutorService

02_Java之 java.util.concurrent 包之ExecutorService之submit () 之 Future

03_Java之多线程之Callable与Future

04_Java之多线程之Lock






-
转载请注明,
原文出处:http://lixh1986.iteye.com/blog/2351294






引用:
http://www.journaldev.com/2377/java-lock-example-reentrantlock

分享到:
评论
1 楼 Lixh1986 2018-11-13  
Java并发编程:自己动手写一把可重入锁
https://blog.csdn.net/zhang5476499/article/details/83794711

相关推荐

    Java多线程编程核心技术_完整版_java_

    Java多线程编程是Java开发中的重要组成部分,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在Java中,多线程主要通过继承Thread类或实现Runnable接口来实现。本教程《Java多线程编程核心技术》将...

    Java多线程练习题

    Java多线程是Java编程中的核心概念,它允许程序同时执行多个任务,提高了系统的效率和响应性。在Java中,多线程的实现主要通过两种方式:继承Thread类和实现Runnable接口。理解并掌握多线程的使用对于任何Java开发者...

    Java多线程技术精讲

    Java多线程技术是Java编程中的重要组成部分,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在现代计算机系统中,多线程是实现并发处理的关键技术,尤其在服务器端应用和高性能计算中不可或缺。 ...

    Java 多线程 PPT

    本文将深入探讨Java多线程的相关概念、线程类和接口的使用,以及线程的同步与互斥。 首先,我们需要理解进程与线程的基本概念。程序是一组静态指令的集合,而进程则是程序在执行过程中的一个实例,拥有独立的内存...

    超实用的Java并发多线程教程

    1. 同步机制:为了解决多线程环境下的数据安全问题,Java提供了多种同步机制,如`synchronized`关键字、`Lock`接口及其子类(如`ReentrantLock`)。 2. `synchronized`关键字:它可以修饰方法或代码块,确保同一时间...

    java多线程进阶

    Java多线程是Java编程中的核心概念,尤其对于高级开发者来说,掌握多线程的深入理解和应用至关重要。这本书“java多线程进阶”显然旨在帮助读者深化这方面的理解,打通编程中的“任督二脉”,使开发者能够更加熟练地...

    java单线程多线程clientserver

    Java多线程则是为了解决这个问题而引入的概念。通过创建多个线程,程序可以在同一时间执行多个任务,提高了CPU的利用率和程序的响应速度。多线程可以分为并发和并行两种。并发是在单核CPU中,通过快速切换线程执行来...

    java多线程作业.docx

    ### Java多线程知识点解析 #### 一、Java多线程概述 Java作为一种现代编程语言,内置了对多线程的支持。多线程允许应用程序同时处理多个任务,从而提高程序的响应性和整体性能。在多线程环境中,一个程序可以包含...

    Java多线程资料

    这篇资料深入探讨了Java多线程的相关知识,包括线程的创建、同步与通信、线程的状态管理等。 1. **线程创建** - 继承Thread类:创建一个新类,该类继承自Thread类,并重写run()方法,然后创建该类的实例并调用...

    【JAVA多线程】多线程编程核心技术学习资料

    Java多线程编程是Java开发中的重要组成部分,它允许程序同时执行多个任务,极大地提高了程序的效率和响应性。在现代计算机系统中,多线程技术尤其关键,因为它们能够充分利用多核处理器的能力。这份"Java多线程编程...

    Java多线程之ReentrantLock与Condition - 平凡希 - 博客园1

    Java中的`ReentrantLock`是Java并发包`java.util.concurrent.locks`中的一个高级锁机制,它是可重入的互斥锁,具有与`synchronized`关键字...在设计和实现多线程程序时,了解和正确使用`ReentrantLock`是非常重要的。

    java socket 多线程并发控制 hibernate mysql

    本项目聚焦于使用Java的Socket进行多线程并发控制,并结合Hibernate ORM框架与MySQL数据库进行数据存储。下面将详细阐述这些技术及其应用。 首先,Java Socket是Java提供的用于实现网络上不同计算机间进程通信的...

    JavaLock与Condition的理解Reentran

    Java Lock与Condition是Java并发编程中的重要概念,它们提供了比synchronized关键字更细粒度的控制,从而使得多线程程序的设计和管理更加灵活高效。本文将深入探讨ReentrantLock(可重入锁)和Condition的基本原理、...

    Java 多线程介绍

    Java多线程是Java编程语言中的一个重要特性,它允许在单个程序中同时执行多个线程,从而提高程序的效率和响应性。本文将深入探讨Java多线程的基础概念、线程的生命周期以及一些关键的线程控制方法,如`suspend()`和`...

    Java程序设计\java 多线程

    下面将详细讲解Java多线程的相关概念、创建线程的方式以及线程同步和调度。 5.1 相关概念: 1. **程序**:一组指令的集合,用于完成特定的任务。 2. **进程**:操作系统中执行程序的实例,每个进程都有自己的内存...

    java多线程

    由于提供的文件内容大部分与Java多线程编程核心技术并无直接关联,而是关于电子书资源的联系方式和说明,因此不能直接从这部分内容中生成关于Java多线程的知识点。但考虑到描述中提到了电子书的标题以及它涉及的主题...

    java多线程实现生产者和消费者

    在Java编程中,多线程是一种重要的技术,它允许程序同时执行多个任务,提升系统效率。在并发编程中,"生产者-消费者"模式是一种经典的解决问题的范式,用于协调两个或更多线程间的协作,其中一部分线程(生产者)...

    java+多线程+同步详解源代码学习

    Java多线程与同步是Java编程中的核心概念,它们在构建高效、响应迅速的应用程序时起着至关重要的作用。在大型系统开发中,多线程技术使得程序能够同时执行多个任务,提高系统的并发性,而同步机制则确保了在多线程...

Global site tag (gtag.js) - Google Analytics