线程的使用—嘀嗒嘀嗒计时器

最新推荐文章于 2021-09-02 09:08:50 发布

Chatouille

最新推荐文章于 2021-09-02 09:08:50 发布

阅读量271

点赞数 1

本文链接：https://blog.csdn.net/weixin_43465687/article/details/86642862

版权

目的

编写一个精确定时的小工具

编程实现

此程序包含两个线程

DidaDida线程：功能是计时，当时间到了则唤醒DidaDidaWorker线程
DidaDidaWorker线程：当时间到了之后要干的事情

这是DidaDida类的三个抽象方法

    public abstract void didadidaRunning();
    public abstract void didadidaStop();
    public abstract void itIsTheTime();

DidaDidaWorker线程

这是一个内部类，当启动这个线程时，先将其wiat()，变成阻塞态，等待被唤醒；这个内部类的作用是到时间之后要干的事情。

    public class DidaDidaWorker implements Runnable {

        public DidaDidaWorker() {
        }

        @Override
        public void run() {
            while (goon) {
                synchronized (this) {
                    try {
                        this.wait();
                        if (goon) {
                            itIsTheTime();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

开始计时

创建一个DidaDidaWorker线程并将其启动（启动后是本线程是阻塞态，并没有开始执行真正的代码）；再创建本类的线程，用wait()将其阻塞，当真正开始运行run()方法的代码时再将其唤醒。

    public void startDidaDida() {
        goon = true;
        worker = new DidaDidaWorker();
        Thread workerThread = new Thread(worker);
        workerThread.setPriority(Thread.MAX_PRIORITY);
        workerThread.start();
        synchronized (lock) {
            new Thread(this, "DidaDida").start();
            try {
                lock.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

本类的线程（DidaDida的线程）

将worker线程wait指定秒数，再将其唤醒，执行itIsTheTime()方法


    @Override
    public void run() {
        synchronized (lock) {
            lock.notify();
        }
        if (waitTime == 0) {
            waitTime = DEFAULT_TIME;
        }
        didadidaRunning();
        while (goon) {
            synchronized (worker) {
                try {
                    worker.wait(waitTime);
                    worker.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        didadidaStop();
    }

测试

public class DidaDidaDemo extends DidaDida {
	private volatile int count;
	private String name;

	public DidaDidaDemo(int didadidaTime, String name) {
		this.name = name;
		setClock(didadidaTime);
	}
	
	public void startDidadida() {
		count = 0;
		startDidaDida();
	}
	
	public void stopDidadida() {
		didadidaStop();
	}
	
	@Override
	public void didadidaRunning() {
		System.out.println(CurrentTime.logMessage("滴答滴答开始工作……"));
	}

	@Override
	public void didadidaStop() {
		System.out.println(CurrentTime.logMessage("滴答滴答停止工作"));
	}

	@Override
	public void itIsTheTime() {
		System.out.println(CurrentTime.logMessage("线程" + name
				+ "：第" + ++count + "次工作！"));
	}
	
}

	public static void main(String[] args) {
		DidaDidaDemo dida1 = new DidaDidaDemo(1000, "第一个");

		Scanner in = new Scanner(System.in);
		String message = "";
		while (!message.equalsIgnoreCase("x")) {
			message = in.nextLine();
			if (message.equalsIgnoreCase("st")) {
				dida1.startDidadida();
			} else if (message.equalsIgnoreCase("sp")) {
				dida1.stopDidaDida();
			}
		}
		
		in.close();
	}

运行结果