第一章 Thread Management(线程管理) 中

最新推荐文章于 2025-09-02 18:18:03 发布

原创最新推荐文章于 2025-09-02 18:18:03 发布 · 408 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#线程 #sleep #join #多线程 #线程异常

Java 7 Concurrency Cookbook 专栏收录该内容

19 篇文章

订阅专栏

本文介绍了Java中线程的高级操作技巧，包括休眠和唤醒线程、等待线程结束、创建守护线程及处理线程异常等内容。通过具体实例展示了如何实现线程间的同步与协调。

涉及内容

创建和运行一个线程
获取和设置线程信息
打断一个线程
控制打断的线程
休眠和唤醒线程
等待线程的终止
创建和运行守护线程
处理线程中不受控制的异常
使用local thread变量
将线程加入组
处理线程组的不受控制的异常
通过工厂创建线程

1、休眠和唤醒线程

例子：使用sleep()方法写一个真实的日期

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class FileClock implements Runnable {

	@Override
	public void run() {
		for(int i=0; i<10; i++) {
			System.out.printf("%s\n", new Date());
			try{
				TimeUnit.SECONDS.sleep(1);

			}catch (InterruptedException e) {
				System.out.printf("FileClock已经被打断了");
			}
		}



	}
	public static void main(String[] args) {
		FileClock clock = new FileClock();
		Thread thread = new Thread(clock);
		thread.start();

		try {
			TimeUnit.SECONDS.sleep(5);
		} catch (InterruptedException e){
			e.printStackTrace();
		}
		thread.interrupt();
	}

}

总结：

1、每秒打印一次日期，到5秒之后被打断，但线程不会停止，因为已经捕获异常。
2、yield()也可以不在使用电脑CPU资源，但是电脑并不一定会执行。一般用于调试目的。

2、等待一个线程的finalization

使用join()方法来完成finalization

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DataSourcesLoader implements Runnable{

	@Override
	public void run() {
		System.out.printf("开始数据加载DataSourcesLoader： %s\n", new Date()	 );
		try {
			TimeUnit.SECONDS.sleep(4);
		}catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("数据加载已经完成DataSourcesLoader：%s\n", new Date());
	}

}

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class NetworkConnectionLoader implements Runnable {

	@Override
	public void run() {
		System.out.printf("开始数据加载NetworkConnectionLoader： %s\n", new Date()	 );
		try {
			TimeUnit.SECONDS.sleep(6);
		}catch (InterruptedException e){
			e.printStackTrace();
		}
		System.out.printf("数据加载已经完成NetworkConnectionLoader：%s\n", new Date());
		
	}

}

import java.util.Date;

public class ThreadTest {

	public static void main(String[] args) {
		DataSourcesLoader dsLoader = new DataSourcesLoader();
		Thread thread1 = new Thread(dsLoader, "DataSourceThread");
		
		NetworkConnectionLoader ncLoader = new NetworkConnectionLoader();
		Thread thread2 = new Thread(ncLoader, "NetworkCOnnectionLoader");
		thread1.start();
		thread2.start();
		try{
				thread1.join();
				thread2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.printf("Main : 配置文件已经加载： %s\n", new Date());
	}
}

总结：

1、join的意思就是加入(说白就是插队，你就是在当前线程插队，类似火车站花10块优先进入站台，他们又不用排队，哈哈)
2、join(long milliseconds)，例如 thread2.join(1000)，必须满足两个条件，1、thread2完成执行，2、过了1000毫秒
3、如果你想要main线程永不停止
while(true) {
thread1.join();
thread2.join();
}

3、创建和运行一个守护线程。

JVM退出之前会关闭守护线程，（垃圾回收机制就是守护线程）

例子：创建两个线程，一个线程写事件队列，一个清除事件队列，不过要等10秒之后清除事件。

import java.util.Date;

public class Event {
	private Date date;
	private String event;
	public Date getDate() {
		return date;
	}
	public String getEvent() {
		return event;
	}
	public void setDate(Date date) {
		this.date = date;
	}
	public void setEvent(String event) {
		this.event = event;
	}
	
	
}


import java.util.Date;
import java.util.Deque;
import java.util.concurrent.TimeUnit;

public class WriterTask implements Runnable {

	private Deque<Event> deque;
	
	public WriterTask(Deque<Event> deque) {
		super();
		this.deque = deque;
	}

	@Override
	public void run() {
		for (int i=1; i<100; i++) {
			Event event = new Event();
			event.setDate(new Date());
			event.setEvent(String.format("这个线程%s已经生产一个事件", Thread.currentThread().getId()));
			System.out.printf("增加：%s\n", event.getEvent() );
			deque.addFirst(event);
			try {
				TimeUnit.SECONDS.sleep(3);
				
			}catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}

}

import java.util.Date;
import java.util.Deque;
import java.util.concurrent.TimeUnit;

public class CleanerTask extends Thread{

	private Deque<Event> deque;

	public CleanerTask(Deque<Event> deque)  {
		this.deque = deque;
		setDaemon(true);
	}

	@Override
	public void run() {
		while(true) {
			Date date = new Date();
			try {
				clean(date);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	private void clean(Date date) throws InterruptedException {
//		必须睡觉，不然话，没有执行机会？？？
		TimeUnit.SECONDS.sleep(1);
		long difference;
		boolean delete;
		
		if(deque.size() == 0) {
			return ;
		}
		delete=false;
	
		do{
			
			Event e = deque.getLast();
			difference = date.getTime() - e.getDate().getTime();
			if(difference > 10000) {
				System.out.printf("清除======：%s\n", e.getEvent() );
				deque.removeLast();
				delete=true;
			}
		} while (difference > 10000);
		if(delete) {
			System.out.printf("清除=======：队列的数量：%d\n", deque.size());
		}
	}
	
	
}

import java.util.ArrayDeque;
import java.util.Deque;

public class ThreadTest {

	public static void main(String[] args) {
		Deque<Event> deque = new ArrayDeque<Event>();
		WriterTask writer = new WriterTask(deque);
		for(int i=0; i<3; i++){
			Thread thread = new Thread(writer);
			thread.start();
			
		}
		CleanerTask cleaner = new CleanerTask(deque);
		cleaner.start();
	}
}

日志：

总结：

1、两个线程必须睡眠，不然会出现只有添加事件的线程运行或只有清除事件线程运行。
2、问题来？为啥都要睡眠，不是睡眠就把控制器交出吗？请求指教，可能是CPU调度算法不一样。

4、处理线程中不受控制的异常

Java分为两类异常

检查异常：这些异常可以进行捕捉，例如IOException、ClassNotFoundException

非检查异常：这些异常不是具体的，不可以被捕捉，例如NumberFormat Exception

幸运的是，Java提供处理非检查异常处理机制

例子：学习这种机制

import java.lang.Thread.UncaughtExceptionHandler;

public class ExceptionHandler implements UncaughtExceptionHandler {

	@Override
	public void uncaughtException(Thread t, Throwable e) {
		System.out.printf("一个异常已经被捕获\n");
		System.out.printf("线程ID: %s\n", t.getId());
		System.out.printf("异常类: %s:  %s\n", e.getClass().getName(), e.getMessage());
		System.out.printf("堆栈信息：\n");
		e.printStackTrace(System.out);
		System.out.printf("线程的状态： %s\n", t.getState());
		
	}

}

public class Task implements Runnable{

	@Override
	public void run() {
		int numero = Integer.parseInt("TTTT");
		
	}

	public static void main(String[] args) {
		Task task = new Task();
		Thread thread = new Thread(task);
		thread.setUncaughtExceptionHandler(new ExceptionHandler());
		thread.start();
	}
}

日志：

一个异常已经被捕获
线程ID: 10
异常类: java.lang.NumberFormatException:  For input string: "TTTT"
堆栈信息：
java.lang.NumberFormatException: For input string: "TTTT"
	at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
	at java.lang.Integer.parseInt(Integer.java:580)
	at java.lang.Integer.parseInt(Integer.java:615)
	at com.jack.Task.run(Task.java:7)
	at java.lang.Thread.run(Thread.java:748)
线程的状态： RUNNABLE

总结：