詳解Java編程中線程同步以及定時啟動線程的方法
使用wait()與notify()實現(xiàn)線程間協(xié)作
1. wait()與notify()/notifyAll()
調用sleep()和yield()的時候鎖并沒有被釋放，而調用wait()將釋放鎖。這樣另一個任務（線程）可以獲得當前對象的鎖，從而進入它的synchronized方法中。可以通過notify()/notifyAll()，或者時間到期，從wait()中恢復執(zhí)行。
只能在同步控制方法或同步塊中調用wait()、notify()和notifyAll()。如果在非同步的方法里調用這些方法，在運行時會拋出IllegalMonitorStateException異常。
2.模擬單個線程對多個線程的喚醒
模擬線程之間的協(xié)作。Game類有2個同步方法prepare()和go()。標志位start用于判斷當前線程是否需要wait()。Game類的實例首先啟動所有的Athele類實例，使其進入wait()狀態(tài)，在一段時間后，改變標志位并notifyAll()所有處于wait狀態(tài)的Athele線程。
Game.java
package concurrency;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
class Athlete implements Runnable {
private final int id;
private Game game;
public Athlete(int id, Game game) {
this.id = id;
this.game = game;
}
public boolean equals(Object o) {
if (!(o instanceof Athlete))
return false;
Athlete athlete = (Athlete) o;
return id == athlete.id;
}
public String toString() {
return "Athlete<" + id + ">";
}
public int hashCode() {
return new Integer(id).hashCode();
}
public void run() {
try {
game.prepare(this);
} catch (InterruptedException e) {
System.out.println(this + " quit the game");
}
}
}
public class Game implements Runnable {
private Set<Athlete> players = new HashSet<Athlete>();
private boolean start = false;
public void addPlayer(Athlete one) {
players.add(one);
}
public void removePlayer(Athlete one) {
players.remove(one);
}
public Collection<Athlete> getPlayers() {
return Collections.unmodifiableSet(players);
}
public void prepare(Athlete athlete) throws InterruptedException {
System.out.println(athlete + " ready!");
synchronized (this) {
while (!start)
wait();
if (start)
System.out.println(athlete + " go!");
}
}
public synchronized void go() {
notifyAll();
}
public void ready() {
Iterator<Athlete> iter = getPlayers().iterator();
while (iter.hasNext())
new Thread(iter.next()).start();
}
public void run() {
start = false;
System.out.println("Ready......");
System.out.println("Ready......");
System.out.println("Ready......");
ready();
start = true;
System.out.println("Go!");
go();
}
public static void main(String[] args) {
Game game = new Game();
for (int i = 0; i < 10; i++)
game.addPlayer(new Athlete(i, game));
new Thread(game).start();
}
}
結果：
Ready...... Ready...... Ready...... Athlete<0> ready! Athlete<1> ready! Athlete<2> ready! Athlete<3> ready! Athlete<4> ready! Athlete<5> ready! Athlete<6> ready! Athlete<7> ready! Athlete<8> ready! Athlete<9> ready! Go! Athlete<9> go! Athlete<8> go! Athlete<7> go! Athlete<6> go! Athlete<5> go! Athlete<4> go! Athlete<3> go! Athlete<2> go! Athlete<1> go! Athlete<0> go!
3.模擬忙等待過程
MyObject類的實例是被觀察者，當觀察事件發(fā)生時，它會通知一個Monitor類的實例（通知的方式是改變一個標志位）。而此Monitor類的實例是通過忙等待來不斷的檢查標志位是否變化。
BusyWaiting.java
import java.util.concurrent.TimeUnit;
class MyObject implements Runnable {
private Monitor monitor;
public MyObject(Monitor monitor) {
this.monitor = monitor;
}
public void run() {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("i'm going.");
monitor.gotMessage();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Monitor implements Runnable {
private volatile boolean go = false;
public void gotMessage() throws InterruptedException {
go = true;
}
public void watching() {
while (go == false)
;
System.out.println("He has gone.");
}
public void run() {
watching();
}
}
public class BusyWaiting {
public static void main(String[] args) {
Monitor monitor = new Monitor();
MyObject o = new MyObject(monitor);
new Thread(o).start();
new Thread(monitor).start();
}
}
結果：
i'm going. He has gone.
4.使用wait()與notify()改寫上面的例子
下面的例子通過wait()來取代忙等待機制，當收到通知消息時，notify當前Monitor類線程。
Wait.java
package concurrency.wait;
import java.util.concurrent.TimeUnit;
class MyObject implements Runnable {
private Monitor monitor;
public MyObject(Monitor monitor) {
this.monitor = monitor;
}
定時啟動線程
這里提供兩種在指定時間后啟動線程的方法。一是通過java.util.concurrent.DelayQueue實現(xiàn)；二是通過java.util.concurrent.ScheduledThreadPoolExecutor實現(xiàn)。
1. java.util.concurrent.DelayQueue
類DelayQueue是一個無界阻塞隊列，只有在延遲期滿時才能從中提取元素。它接受實現(xiàn)Delayed接口的實例作為元素。
<<interface>>Delayed.java
package java.util.concurrent;
import java.util.*;
public interface Delayed extends Comparable<Delayed> {
long getDelay(TimeUnit unit);
}
getDelay()返回與此對象相關的剩余延遲時間，以給定的時間單位表示。此接口的實現(xiàn)必須定義一個 compareTo 方法，該方法提供與此接口的 getDelay 方法一致的排序。
DelayQueue隊列的頭部是延遲期滿后保存時間最長的 Delayed 元素。當一個元素的getDelay(TimeUnit.NANOSECONDS) 方法返回一個小于等于 0 的值時，將發(fā)生到期。
2.設計帶有時間延遲特性的隊列
類DelayedTasker維護一個DelayQueue<DelayedTask> queue，其中DelayedTask實現(xiàn)了Delayed接口，并由一個內部類定義。外部類和內部類都實現(xiàn)Runnable接口，對于外部類來說，它的run方法是按定義的時間先后取出隊列中的任務，而這些任務即內部類的實例，內部類的run方法定義每個線程具體邏輯。
這個設計的實質是定義了一個具有時間特性的線程任務列表，而且該列表可以是任意長度的。每次添加任務時指定啟動時間即可。
DelayedTasker.java
package com.zj.timedtask;
import static java.util.concurrent.TimeUnit.SECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import java.util.Collection;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class DelayedTasker implements Runnable {
DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
public void addTask(DelayedTask e) {
queue.put(e);
}
public void removeTask() {
queue.poll();
}
public Collection<DelayedTask> getAllTasks() {
return Collections.unmodifiableCollection(queue);
}
public int getTaskQuantity() {
return queue.size();
}
public void run() {
while (!queue.isEmpty())
try {
queue.take().run();
} catch (InterruptedException e) {
System.out.println("Interrupted");
}
System.out.println("Finished DelayedTask");
}
public static class DelayedTask implements Delayed, Runnable {
private static int counter = 0;
private final int id = counter++;
private final int delta;
private final long trigger;
public DelayedTask(int delayInSeconds) {
delta = delayInSeconds;
trigger = System.nanoTime() + NANOSECONDS.convert(delta, SECONDS);
}
public long getDelay(TimeUnit unit) {
return unit.convert(trigger - System.nanoTime(), NANOSECONDS);
}
public int compareTo(Delayed arg) {
DelayedTask that = (DelayedTask) arg;
if (trigger < that.trigger)
return -1;
if (trigger > that.trigger)
return 1;
return 0;
}
public void run() {
//run all that you want to do
System.out.println(this);
}
public String toString() {
return "[" + delta + "s]" + "Task" + id;
}
}
public static void main(String[] args) {
Random rand = new Random();
ExecutorService exec = Executors.newCachedThreadPool();
DelayedTasker tasker = new DelayedTasker();
for (int i = 0; i < 10; i++)
tasker.addTask(new DelayedTask(rand.nextInt(5)));
exec.execute(tasker);
exec.shutdown();
}
}
結果：
[0s]Task 1 [0s]Task 2 [0s]Task 3 [1s]Task 6 [2s]Task 5 [3s]Task 8 [4s]Task 0 [4s]Task 4 [4s]Task 7 [4s]Task 9 Finished DelayedTask
3. java.util.concurrent.ScheduledThreadPoolExecutor
該類可以另行安排在給定的延遲后運行任務（線程），或者定期（重復）執(zhí)行任務。在構造子中需要知道線程池的大小。最主要的方法是：
[1] schedule
public ScheduledFuture<?> schedule(Runnable command, long delay,TimeUnit unit)
創(chuàng)建并執(zhí)行在給定延遲后啟用的一次性操作。
指定者：
-接口 ScheduledExecutorService 中的 schedule;
參數(shù)：
-command - 要執(zhí)行的任務 ;
-delay - 從現(xiàn)在開始延遲執(zhí)行的時間 ;
-unit - 延遲參數(shù)的時間單位 ;
返回：
-表示掛起任務完成的 ScheduledFuture，并且其 get() 方法在完成后將返回 null。
[2] scheduleAtFixedRate
public ScheduledFuture<?> scheduleAtFixedRate(
Runnable command,long initialDelay,long period,TimeUnit unit)
創(chuàng)建并執(zhí)行一個在給定初始延遲后首次啟用的定期操作，后續(xù)操作具有給定的周期；也就是將在 initialDelay 后開始執(zhí)行，然后在 initialDelay+period 后執(zhí)行，接著在 initialDelay + 2 * period 后執(zhí)行，依此類推。如果任務的任何一個執(zhí)行遇到異常，則后續(xù)執(zhí)行都會被取消。否則，只能通過執(zhí)行程序的取消或終止方法來終止該任務。如果此任務的任何一個執(zhí)行要花費比其周期更長的時間，則將推遲后續(xù)執(zhí)行，但不會同時執(zhí)行。
指定者：
-接口 ScheduledExecutorService 中的 scheduleAtFixedRate;
參數(shù)：
-command - 要執(zhí)行的任務 ;
-initialDelay - 首次執(zhí)行的延遲時間 ;
-period - 連續(xù)執(zhí)行之間的周期 ;
-unit - initialDelay 和 period 參數(shù)的時間單位 ;
返回：
-表示掛起任務完成的 ScheduledFuture，并且其 get() 方法在取消后將拋出異常。
4.設計帶有時間延遲特性的線程執(zhí)行者
類ScheduleTasked關聯(lián)一個ScheduledThreadPoolExcutor，可以指定線程池的大小。通過schedule方法知道線程及延遲的時間，通過shutdown方法關閉線程池。對于具體任務（線程）的邏輯具有一定的靈活性（相比前一中設計，前一種設計必須事先定義線程的邏輯，但可以通過繼承或裝飾修改線程具體邏輯設計）。
ScheduleTasker.java
package com.zj.timedtask;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ScheduleTasker {
private int corePoolSize = 10;
ScheduledThreadPoolExecutor scheduler;
public ScheduleTasker() {
scheduler = new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduleTasker(int quantity) {
corePoolSize = quantity;
scheduler = new ScheduledThreadPoolExecutor(corePoolSize);
}
public void schedule(Runnable event, long delay) {
scheduler.schedule(event, delay, TimeUnit.SECONDS);
}
public void shutdown() {
scheduler.shutdown();
}
public static void main(String[] args) {
ScheduleTasker tasker = new ScheduleTasker();
tasker.schedule(new Runnable() {
public void run() {
System.out.println("[1s]Task 1");
}
}, 1);
tasker.schedule(new Runnable() {
public void run() {
System.out.println("[2s]Task 2");
}
}, 2);
tasker.schedule(new Runnable() {
public void run() {
System.out.println("[4s]Task 3");
}
}, 4);
tasker.schedule(new Runnable() {
public void run() {
System.out.println("[10s]Task 4");
}
}, 10);
tasker.shutdown();
}
}
結果：
[1s]Task 1
[2s]Task 2
[4s]Task 3
[10s]Task 4
public void run() {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("i'm going.");
monitor.gotMessage();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Monitor implements Runnable {
private volatile boolean go = false;
public synchronized void gotMessage() throws InterruptedException {
go = true;
notify();
}
public synchronized void watching() throws InterruptedException {
while (go == false)
wait();
System.out.println("He has gone.");
}
public void run() {
try {
watching();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Wait {
public static void main(String[] args) {
Monitor monitor = new Monitor();
MyObject o = new MyObject(monitor);
new Thread(o).start();
new Thread(monitor).start();
}
}
結果：
i'm going. He has gone.
相關文章
這篇文章主要介紹了Java分層概念詳解，內容十分詳細，在這里給大家分享下，需要的朋友可以參考。2017-09-09
探究Android系統(tǒng)中解析JSON數(shù)據(jù)的方式
這篇文章主要介紹了探究Android系統(tǒng)中解析JSON數(shù)據(jù)的方式,文中講到了使用Java代碼實現(xiàn)的處理JSON的一些主要方法,需要的朋友可以參考下2015-07-07
Java Web項目中實現(xiàn)文件下載功能的實例教程
這篇文章主要介紹了Java Web項目中實現(xiàn)文件下載功能的實例教程,分別講解了通過超鏈接實現(xiàn)下載以及通過Servlet程序實現(xiàn)下載的方式,需要的朋友可以參考下2016-05-05
這篇文章主要為大家詳細介紹了Java設計模式之模板方法模式，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助2022-03-03
java application maven項目打自定義zip包實例(推薦)
下面小編就為大家?guī)硪黄猨ava application maven項目打自定義zip包實例(推薦)。小編覺得挺不錯的，現(xiàn)在就分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-05-05
這篇文章主要介紹了JVM內存結構劃分實例解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-12-12
IDEA使用學生郵箱無法注冊問題:JetBrains Account connection error: 拒絕連接
這篇文章主要介紹了IDEA使用學生郵箱無法注冊問題:JetBrains Account connection error: 拒絕連接,文中通過圖文及示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-07-07
URL類提供了一個openConnection()方法，可以打開一個連接并返回一個URLConnection對象，該對象可以用來檢查連接是否有效，這篇文章主要介紹了Java判斷一個url是否有效，需要的朋友可以參考下2023-09-09
這篇文章主要介紹了MyEclipse10安裝Log4E插件的相關資料,需要的朋友可以參考下2017-10-10
實際開發(fā)中緩存處理是必須的，不可能我們每次客戶端去請求一次服務器，服務器每次都要去數(shù)據(jù)庫中進行查找，為什么要使用緩存？說到底是為了提高系統(tǒng)的運行速度2023-01-01