Java并发学习之十四——使用Lock同步代码块

本文是学习网络上的文章时的总结,感谢大家无私的分享。

Java提供另外的机制用来同步代码块。它比synchronized关键字更加强大、灵活。Lock
接口比synchronized关键字提供更多额外的功能。在使用Lock时需要注意的是要释放Lock锁。

package chapter2;

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

/*
 * 打印队列
 */
public class PrintQueue {
	private final Lock queueLock = new ReentrantLock();
	public void printJob(Object document){
		queueLock.lock();//获取Lock对象的控制权

		try {
			Long duration = (long)(Math.random()*10000);
			System.out.println(Thread.currentThread().getName()
					+"PrintQueue:Printing a Job during "
					+(duration/1000)+" seconds");
			Thread.sleep(duration);
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			queueLock.unlock();//释放Lock对象的控制
		}
	}
}
package chapter2;

public class Job implements Runnable{
	private PrintQueue printQueue;
	public Job(PrintQueue printQueue){
		this.printQueue = printQueue;
	}
	@Override
	public void run() {
		System.out.printf("%s:Going to print a document\n",
				Thread.currentThread().getName());
		printQueue.printJob(new Object());
		System.out.printf("%s:The document has been printed\n",Thread.currentThread().getName());
	}

}
package chapter2;
/**
 *
 * <p>
 * Description: 使用Lock同步代码块
 * </p>
 * @author zhangjunshuai
 * @version 1.0
 * Create Date: 2014-9-16 下午4:57:06
 * Project Name: Java7Thread
 *
 * <pre>
 * Modification History:
  *             Date                                Author                   Version          Description
 * -----------------------------------------------------------------------------------------------------------
 * LastChange: $Date::             $      $Author: $          $Rev: $
 * </pre>
 *
 */
public class Main5 {

	/**
	 * <p>
	 * </p>
	 * @author zhangjunshuai
	 * @date 2014-9-16 下午4:57:00
	 * @param args
	 */
	public static void main(String[] args) {

		PrintQueue printQueue = new PrintQueue();
		Thread thread[] = new Thread[10];
		for(int i=0;i<10;i++){
			thread[i] = new Thread(new Job(printQueue),"Thread"+i);
		}
		for(int i=0;i<10;i++){
			thread[i].start();
		}
	}

}
时间: 2025-01-03 23:21:31

Java并发学习之十四——使用Lock同步代码块的相关文章

JAVA之旅(十四)——静态同步函数的锁是class对象,多线程的单例设计模式,死锁,线程中的通讯以及通讯所带来的安全隐患,等待唤醒机制

JAVA之旅(十四)--静态同步函数的锁是class对象,多线程的单例设计模式,死锁,线程中的通讯以及通讯所带来的安全隐患,等待唤醒机制 JAVA之旅,一路有你,加油! 一.静态同步函数的锁是class对象 我们在上节验证了同步函数的锁是this,但是对于静态同步函数,你又知道多少呢? 我们做一个这样的小实验,我们给show方法加上static关键字去修饰 private static synchronized void show() { if (tick > 0) { try { Thread

No_16_0325 Java基础学习第二十四天—多线程学习总结

文档版本 开发工具 测试平台 工程名字 日期 作者 备注 V1.0 2016.03.25 lutianfei none 第十章 多线程 多线程概述 什么是进程? 进程:就是正在运行的程序. 进程是系统进行资源分配和调用的独立单位.每一个进程都有它自己的内存空间和系统资源. 多进程有什么意义呢? 可以在一个时间段内执行多个任务. 可以提高CPU的使用率. 什么是线程呢? 在同一个进程内又可以执行多个任务,而这每一个任务我就可以看出是一个线程. 线程:是程序的执行单元,执行路径.是程序使用CPU的最

java并发编程(十四)同步问题的内存可见性

转载请注明出处:http://blog.csdn.net/ns_code/article/details/17288243 加锁(synchronized同步)的功能不仅仅局限于互斥行为,同时还存在另外一个重要的方面:内存可见性.我们不仅希望防止某个线程正在使用对象状态而另一个线程在同时修改该状态,而且还希望确保当一个线程修改了对象状态后,其他线程能够看到该变化.而线程的同步恰恰也能够实现这一点. 置锁可以用于确保某个线程以一种可预测的方式来查看另一个线程的执行结果.为了确保所有的线程都能看到共

Java并发学习之十六——线程同步工具之信号量(Semaphores)

本文是学习网络上的文章时的总结,感谢大家无私的分享. 当一个线程想要访问某个共享资源,首先,它必须获得semaphore.如果semaphore的内部计数器的值大于0,那么semaphore减少计数器的值并允许访问共享的资源.计数器的值大于0表示,有可以自由使用的资源,所以线程可以访问并使用它们. package chapter3; import java.util.concurrent.Semaphore; public class PrintQueue2 { private final Se

Java并发学习之十二——在同步的类里安排独立属性

本文是学习网络上的文章时的总结,感谢大家无私的分享. 当你使用synchronized关键字来保护代码块时,你必须通过一个对象的引用作为参数.通常,你将会使用this关键字来引用执行该方法的对象,但是你也可以使用其他对象引用.通常情况下,这些对象被创建只有这个目的.比如,你在一个类中有被多个线程共享的两个独立属性.你必须同步访问每个变量,如果有一个线程访问一个属性和另一个线程在同一时刻访问另一个属性,这是没有问题的. 当你使用synchronized关键字来保护代码块,你使用一个对象作为参数.J

Java并发学习之十九——线程同步工具之Phaser

本文是学习网络上的文章时的总结.感谢大家无私的分享. JDK 1.7 加入了一个新的工具Phaser.Phaser的在功能上与CountDownLatch有部分重合. 以下使用Phaser类来同步3个并发任务. 这3个任务会在3个不同的目录和它们的子目录中搜索扩展名是.log的文件. 这个任务被分成3个步骤: 1. 在指定的目录和子目录中获得文件扩展名为.log的文件列表. 2. 在操控台打印结果. 在步骤1和步骤2的结尾我们要检查列表是否为空. 假设为空.那么线程直接结束执行并从phaser类

Java并发学习之十五——使用读写锁同步数据访问

本文是学习网络上的文章时的总结,感谢大家无私的分享. 读写锁重要的是写锁的使用,只用一个入口. 下面是读写锁使用的例子 package chapter2; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class PricesInfo { private int price1; private int price2;

Java并发编程(十四):Callable、Future和FutureTask(转载)

本文转载自:ttp://www.cnblogs.com/dolphin0520/p/3949310.html 在前面的文章中我们讲述了创建线程的2种方式,一种是直接继承Thread,另外一种就是实现Runnable接口. 这2种方式都有一个缺陷就是:在执行完任务之后无法获取执行结果. 如果需要获取执行结果,就必须通过共享变量或者使用线程通信的方式来达到效果,这样使用起来就比较麻烦. 而自从Java 1.5开始,就提供了Callable和Future,通过它们可以在任务执行完毕之后得到任务执行结果

Java并发学习之十八——线程同步工具之CyclicBarrier

本文是学习网络上的文章时的总结,感谢大家无私的分享. CyclicBarrier 类有一个整数初始值,此值表示将在同一点同步的线程数量.当其中一个线程到达确定点,它会调用await() 方法来等待其他线程.当线程调用这个方法,CyclicBarrier阻塞线程进入休眠直到其他线程到达.当最后一个线程调用CyclicBarrier 类的await() 方法,它唤醒所有等待的线程并继续执行它们的任务. 注意比较CountDownLatch和CyclicBarrier: 1.CountDownLatc