1.7守护线程的创建与运行

1.创建一个实现Runnable接口的WriteTask类，每隔1秒向队列中添加一个Event对象。

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

public class WriteTask implements Runnable{

    /**
     * Data structure to stores the events
     */
    Deque<Event> deque;

    /**
     * Constructor of the class
     * @param deque data structure that stores the event
     */
    public WriteTask (Deque<Event> deque){
        this.deque=deque;
    }

    /**
     * Main class of the Runnable
     */
    @Override
    public void run() {

        // Writes 100 events
        for (int i=1; i<100; i++) {
            // Creates and initializes the Event objects 
            Event event=new Event();
            event.setDate(new Date());
            event.setEvent(String.format("The thread %s has generated an event",Thread.currentThread().getId()));

            // Add to the data structure
            deque.addFirst(event);
            try {
                // Sleeps during one second
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.创建一个继承Thread类的CleanerTask类，该线程被设置成守护线程，作用是将队列中创建超过10秒的最后一个Event从该队列中删除，打印出信息，并重新统计队列的长度。

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

public class CleanerTask extends Thread{

    /**
     * Data structure that stores events
     */
    private Deque<Event> deque;

    /**
     * Constructor of the class
     * @param deque data structure that stores events
     */
    public CleanerTask(Deque<Event> deque) {
        this.deque = deque;
        // Establish that this is a Daemon Thread
        setDaemon(true);
    }


    /**
     * Main method of the class
     */
    @Override
    public void run() {
        while (true) {
            Date date = new Date();
            clean(date);
        }
    }

    /**
     * Method that review the Events data structure and delete
     * the events older than ten seconds
     * @param date
     */
    private void clean(Date date) {
        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("Cleaner: %s\n",e.getEvent());
                deque.removeLast();
                delete=true;
            }   
        } while (difference > 10000);
        if (delete){
            System.out.printf("Cleaner: Size of the queue: %d\n",deque.size());
        }
    }
}

3.主类的实现

先让不断添加Event对象的线程跑起来，等待5秒之后，启动守护线程，守护线程不断地将生成时间超过10秒的队列中最后一个Event对象删除。

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

public class ProtectMain {

public static void main(String[] args) {

        // Creates the Event data structure
        Deque<Event> deque=new ArrayDeque<Event>();

        // Creates the three WriterTask and starts them
        WriteTask writer=new WriteTask(deque);
        for (int i=0; i<3; i++){
            Thread thread=new Thread(writer);
            thread.start();
        }

        try
        {
            TimeUnit.SECONDS.sleep(5);//休眠5秒
        }catch(InterruptedException e)
        {
            e.printStackTrace();
        }

        // Creates a cleaner task and starts them
        CleanerTask cleaner=new CleanerTask(deque);
        cleaner.start();

    }
}

4.运行结果

可以看到的是经过一段时间的运行，队列中的Event对象数量始终维持在30以内。