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

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

JDK 1.7 加入了一个新的工具Phaser。Phaser的在功能上与CountDownLatch有部分重合。

以下使用Phaser类来同步3个并发任务。

这3个任务会在3个不同的目录和它们的子目录中搜索扩展名是.log的文件。

这个任务被分成3个步骤:

1. 在指定的目录和子目录中获得文件扩展名为.log的文件列表。

2. 在操控台打印结果。

在步骤1和步骤2的结尾我们要检查列表是否为空。

假设为空。那么线程直接结束执行并从phaser类中淘汰。

package chapter3;

import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit;

public class FileSearch implements Runnable{

	private String initPath;
	private String end;
	private List<String> results;

	private Phaser phaser;

	public FileSearch(String initPath,String end,Phaser phaser ){
		this.initPath = initPath;
		this.end = end;
		this.phaser = phaser;
		this.results = new ArrayList<String>();
	}

	private void directoryProcess(File file){
		File list[] = file.listFiles();
		if(list != null){
			for(int i = 0;i< list.length;i++){
				if(list[i].isDirectory()
						){
					directoryProcess(list[i]);
				}else{
					fileProcess(list[i]);
				}
			}
		}
	}
	private void fileProcess(File file){
		if(file.getName().endsWith(end)){
			results.add(file.getAbsolutePath());
		}
	}

	private void filterResults(){
		List<String> newResults = new ArrayList<String>();
		long actualDate = new Date().getTime();
		for (int i = 0; i < results.size(); i++) {
			File file = new File(results.get(i));
			long fileDate = file.lastModified();
			if(actualDate-fileDate<TimeUnit.MILLISECONDS.convert(1, TimeUnit.DAYS)){
				newResults.add(results.get(i));
			}
		}
		results = newResults;
	}

	private boolean checkResults(){
		if(results.isEmpty()){
			System.out.printf("%s: Phase %d: 0 results.\n", Thread
					.currentThread().getName(), phaser.getPhase());
					System.out.printf("%s: Phase %d: End.\n", Thread.currentThread()
					.getName(), phaser.getPhase());
					phaser.arriveAndDeregister();
			return false;

		}else{
			System.out.printf("%s: Phase %d: %d results.\n", Thread
					.currentThread().getName(), phaser.getPhase(), results
					.size());
					phaser.arriveAndAwaitAdvance();
			return true;
		}
	}

	private void showInfo(){
		for (int i = 0; i < results.size(); i++) {
			File file = new File(results.get(i));
			System.out.printf("%s: %s\n", Thread.currentThread().getName(),
					file.getAbsolutePath());

		}
		phaser.arriveAndAwaitAdvance();
	}

	@Override
	public void run() {
		phaser.arriveAndAwaitAdvance();
		System.out.printf("%s: Starting.\n", Thread.currentThread().getName());

		File file = new File(initPath);
		if(file.isDirectory()){
			directoryProcess(file);
		}
		if(!checkResults()){
			return ;
		}
		filterResults();
		if(!checkResults()){
			return;
		}
		showInfo();
		phaser.arriveAndDeregister();
		System.out.printf("%s: Work completed.\n", Thread.currentThread()
				.getName());

	}

}
package chapter3;

import java.util.concurrent.Phaser;

public class Main5 {

	/**
	 * <p>
	 * </p>
	 * @author zhangjunshuai
	 * @date 2014-9-29 下午4:31:46
	 * @param args
	 */
	public static void main(String[] args) {
		Phaser phaser = new Phaser(3);

		FileSearch system = new FileSearch("C:\\Windows","log",phaser);
		FileSearch apps = new FileSearch("c:\\Program Files","log",phaser);
		FileSearch documents = new FileSearch("c:\\Documents And Settings","log",phaser);

		Thread systemThread = new Thread(system,"System");
		systemThread.start();

		Thread appsThread = new Thread(apps,"apps");
		appsThread.start();

		Thread documentsThread = new Thread(documents,"documents");
		documentsThread.start();

		try {
			systemThread.join();
			appsThread.join();
			documentsThread.join();
		} catch (Exception e) {
			e.printStackTrace();
		}

		System.out.println("Terminated: " + phaser.isTerminated());

	}

}

执行结果

时间: 2024-10-05 14:50:32

Java并发学习之十九——线程同步工具之Phaser的相关文章

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

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

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

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

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

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

Java并发学习之十——用线程工厂创建线程

本文是学习网络上的文章时的总结,感谢大家无私的分享. 1.工厂模式是最有用的设计模式.它是一个创造模式,还有他的目的是创建一个 或者几个类对象的对象.有了这个工厂,我们有这些优势集中创建对象: 更简单的改变了类的对象创建或者说创建这些对象的方式: 更简单的为了限制的资源限制了对象的创建. 更简单的生成创建对象的统计数据. 2.Java提供一个接口,ThreadFactory接口实现一个线程对象工厂 package chapter; import java.util.ArrayList; impo

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

本文是学习网络上的文章时的总结,感谢大家无私的分享. Java提供另外的机制用来同步代码块.它比synchronized关键字更加强大.灵活.Lock 接口比synchronized关键字提供更多额外的功能.在使用Lock时需要注意的是要释放Lock锁. package chapter2; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * 打印队列 */ pu

java系统学习(十) --------线程

线程的基本概念 进程以及使用环境 程序是计算机指令的集合,它以文件形式存储在磁盘上,而进程就是一个执行中的程序,每一个进程都有其独立的内存空间和系统资源.进程就是一个运行的程序,Windows操作系统是支持多进程的操作系统,即同一时间l可以执行多个程序,每个程序是在自己独立的内存空间内,使用自己被分配到的系统资源.其实,这种说法并不准确,一个CPU在某个时刻,实际上只能运行一个程序,即一个进程.所谓的支持多进程,其实就是CPU在非常快速的交替轮流执行多个程序,例如,利用Windows操作系统可以

java并发编程10.构建自定义的同步工具

创建状态依赖类的最简单方法通常是在类库中现有状态依赖类的基础上进行构造.如果类库中没有提供你需要的功能,可以使用java语言和类库提供的底层机制来构造自己的同步机制,包括内置的条件队列.显示地Condition对象以及AbstractQueuedSynchronizer框架. 在单线程程序中调用方法时,如果基于某个状态的前提条件未得到满足,那么这个条件永远无法成真.而在并发程序中,基于状态的条件可能会由于其他线程的操作而改变. 可阻塞的状态依赖操作 acquire lock on object

Java 并发编程(四)常用同步工具类

同步工具类可以使任何一种对象,只要该对象可以根据自身的状态来协调控制线程的控制流.阻塞队列可以作为同步工具类,其他类型的同步工具类还包括:信号量(Semaphore).栅栏(Barrier)以及闭锁(Latch). 闭锁 首先我们来介绍闭锁. 闭锁作用相当于一扇门:在闭锁到达某一状态之前,这扇门一直是关闭的,所有的线程都会在这扇门前等待(阻塞).只有门打开后,所有的线程才会同时继续运行. 闭锁可以用来确保某些活动直到其它活动都完成后才继续执行,例如: 1.确保某个计算在其所有资源都被初始化之后才

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

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