Java并发编程-03-守护线程的创建和运行

一、守护线程

1、守护线程的优先级很低

2、当一个应用程序里没有其他线程运行的时候，守护线程才运行。

3、当守护线程是唯一运行的线程时，守护线程运行结束后，JVM也就结束了这个程序

4、守护线程被用来作为同一程序中普通线程(也称为用户线程)的服务提供者。

5、守护线程通常是无线循环的，以等待服务请求或者执行线程的任务。

6、我们无法知道守护线程什么时候可以获取cpu的时钟

7、在其他线程运行的时候，守护线程也可能随时结束

8、java中守护线程的带表是java的垃圾回收器

二、测试守护线程

1、创建用户线程，负责将事件写入队列

2、创建守护线程，管理这个队列。

3、函数是setDaemon

public final void setDaemon(boolean on) {
        checkAccess();
        if (isAlive()) {
            throw new IllegalThreadStateException();
        }
        daemon = on;
    }

三、源码

package com.concurrent.threadManager;

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

/**
 * 这是用户线程 负责每隔一秒，向队列写入一个event事件
 * 
 * @author Nicholas
 *
 */

class Event {

	private Date date;
	private String event;

	public Date getDate() {
		return date;
	}

	public void setDate(Date date) {
		this.date = date;
	}

	public String getEvent() {
		return event;
	}

	public void setEvent(String event) {
		this.event = event;
	}

}

public class WriteTask implements Runnable {

	private Deque<Event> dequeEvent;

	public WriteTask(Deque<Event> dequeEvent) {
		this.dequeEvent = dequeEvent;
	}

	@Override
	public void run() {
		for (int i = 1; i < 100; i++) {
			Event event = new Event();
			event.setDate(new Date());
			event.setEvent(String.format(
					"The thread %s has generated an event", Thread
							.currentThread().getId()));
			dequeEvent.addFirst(event);

			try {
				TimeUnit.SECONDS.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

package com.concurrent.threadManager;

import java.util.Date;
import java.util.Deque;

public class CleanTask extends Thread {

	private Deque<Event> dequeEvent;

	public CleanTask(Deque<Event> dequeEvent) {
		this.dequeEvent = dequeEvent;
		setDaemon(true);
	}

	@Override
	public void run() {
		while (true) {
			Date date = new Date();
			Clean(date);
		}
	}

	// 读取队列的最后一个事件对象，如果这个事件是10秒钟前创建的，则删除，然后检查下一个
	private void Clean(Date date) {
		long difference;
		boolean delete;
		if (dequeEvent.size() <= 0)
			return;
		delete = false;

		System.out.println("--------------------------");
		do {
			Event event = dequeEvent.getLast();
			difference = date.getTime() - event.getDate().getTime();
			if (difference > 10000) {
				System.out.printf("Cleaner : %s\n", event.getEvent());
				dequeEvent.removeLast();
				delete = true;
			}
		} while (difference > 10000);

		if (delete) {
			System.out.println("Cleaner : Size of the queue :"
					+ dequeEvent.size());
		}
	}
}

测试

	public void testDaemon() {
		// 创建队列对象，用来保存事件
		Deque<Event> dEvents = new ArrayDeque<Event>();

		WriteTask writeTask = new WriteTask(dEvents);
		for (int i = 0; i < 3; i++) {
			Thread thread = new Thread(writeTask);
			thread.start();
		}
		CleanTask cleanTask = new CleanTask(dEvents);
		cleanTask.start();
	}