Java并发：线程基础

public class LiftOff implements Runnable { // 实现 Runnable 接口

	protected int countDown = 10; //Default
	private static int taskCount = 0;
	private final int id = taskCount++;
	public LiftOff() {}
	public LiftOff(int countDown) {
		this.countDown = countDown;
	}
	
	public String status() {
		return "#Thread id: " + id + ", time: " + (countDown > 0 ? countDown : "Liftoff!");
	}
	
	@Override
	public void run() { // 定义需要做的任务
		while(countDown-- > 0) {
		System.out.println(status());
		Thread.yield();
		}
	}
}

public class BasicThreads {
	public static void main(String[] args) {
		Thread thread = new Thread(new LiftOff());
		thread.start();
		System.out.println("Waiting for LiftOff");
	}
}

public class MoreBasicThreads {
	public static void main(String[] args) {
		for(int i = 0; i < 5; i++) {
			new Thread(new LiftOff()).start();
		}
		System.out.println("Waiting for LiftOff");
	}
}

public class CachedThreadPool {
  public static void main(String[] args) {
	ExecutorService exec = Executors.newCachedThreadPool();
	for(int i = 0; i < 5; i++) {
	  exec.execute(new LiftOff());
	}
	exec.shutdown();
  }
}

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class TaskWithResult implements Callable<String> {

  private int id;

  public TaskWithResult(int id) {
	this.id = id;
  }

  @Override
  public String call() {
	return "result of TaskWithResult: " + id;
  }
}

public class CallableDemo {
  public static void main(String[] args) {
	ExecutorService exec = Executors.newCachedThreadPool();
	ArrayList<Future<String>> result = new ArrayList<Future<String>>();
	for (int i = 0; i < 10; i++) {
	  result.add(exec.submit(new TaskWithResult(i)));
	}
	
	for(Future<String> fs : result) {
	  try {
		System.out.println(fs.get());
	  } catch (InterruptedException | ExecutionException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	  } finally {
		exec.shutdown();
	  }
	}
  }
}/*output:
result of TaskWithResult: 0
result of TaskWithResult: 1
result of TaskWithResult: 2
result of TaskWithResult: 3
result of TaskWithResult: 4
result of TaskWithResult: 5
result of TaskWithResult: 6
result of TaskWithResult: 7
result of TaskWithResult: 8
result of TaskWithResult: 9
*/

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class SleepingTask extends LiftOff {
  @Override
  public void run() {
	try {
	  while(countDown-- > 0) {
		System.out.println(status());
		// Old-style:
		// Thread.sleep(100);
		// Java SE5/6-style:
		TimeUnit.MILLISECONDS.sleep(100);
	  }
	} catch(InterruptedException e) {
	  System.err.println("Interrupted");
	}
  }
  
  public static void main(String[] args) {
	ExecutorService exec = Executors.newCachedThreadPool();
	for(int i = 0; i < 5; i++) {
	  exec.execute(new SleepingTask());
	}
	System.out.println("Waiting For LiftOff");
	exec.shutdown();
  }
}

import java.util.concurrent.TimeUnit;

public class SimpleDaemons implements Runnable {
  @Override
  public void run() {
	try {
	  while (true) {
		TimeUnit.MILLISECONDS.sleep(100);
		System.out.println(Thread.currentThread() + " " + this);
	  }
	} catch (InterruptedException e) {
	  System.out.println("sleep() interrupted");
	  e.printStackTrace();
	}
  }
  
  public static void main(String[] args) throws InterruptedException {
	for(int i = 0; i < 10; i++) {
	  Thread daemon = new Thread(new SimpleDaemons());
	  daemon.setDaemon(true); // Must call before start();
	  daemon.start();
	}
	System.out.println("All daemons started");
	TimeUnit.MILLISECONDS.sleep(275); //不断调整这个时间，就能理解上面那段话了。
  }
}

class Sleeper extends Thread {
  private int duration;
  public Sleeper(String name, int sleepTime) {
	super(name);
	duration = sleepTime;
	start();
  }
  
  public void run() {
	try {
	  sleep(duration);
	} catch(InterruptedException e) {
	  System.out.println(getName() + " was interrupted. " + "isInterrupted(): " + isInterrupted());
	  return ;
	}
	System.out.println(getName() + " has awakened");
  }
}

class Joiner extends Thread {
  private Sleeper sleeper;
  public Joiner(String name, Sleeper sleeper) {
	super(name);
	this.sleeper = sleeper;
	start();
  }
  
  public void run() {
	try {
	  sleeper.join();
	} catch(InterruptedException e) {
	  System.out.println("Interrpted");
	}
	System.out.println(getName() + " join completed");
  }
}

public class Joining {
  public static void main(String[] args) {
	Sleeper sleepy = new Sleeper("Sleepy", 1500);
	Sleeper grumpy = new Sleeper("grumpy", 1500);
	
	Joiner dopey = new Joiner("Dopey", sleepy);
	Joiner doc = new Joiner("Doc", grumpy);
	
	grumpy.interrupt();
  }
}/*output:
grumpy was interrupted. isInterrupted(): false
Doc join completed
Sleepy has awakened
Dopey join completed
*/

 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class ExceptionThread implements Runnable {
   @Override
   public void run() {
	 throw new RuntimeException();
   }
 
   public static void main(String[] args) {
	 try {
	   ExecutorService exec = Executors.newCachedThreadPool();
	   exec.execute(new ExceptionThread());
	 } catch (Exception e) {
	   System.out.println("catch run() exception...");
	 }
   }
 }

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;

class ExceptionThread2 implements Runnable {
  @Override
  public void run() {
	Thread t = Thread.currentThread();
	System.out.println("run() by " + t);
	System.out.println("eh = " + t.getUncaughtExceptionHandler());
	throw new RuntimeException();
  }
}

class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
  @Override
  public void uncaughtException(Thread t, Throwable e) {
	System.out.println("caught " + e);
  }
}

class HandlerThreadFactory implements ThreadFactory {
  @Override
  public Thread newThread(Runnable r) {
	System.out.println(this + " creating new Thread");
	Thread t = new Thread(r);
	System.out.println("created " + t);
	t.setUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
	System.out.println("eh = " + t.getUncaughtExceptionHandler());
	return t;
  }
}

public class CaptureUncaughtException {
  public static void main(String[] args) {
	ExecutorService exec = Executors.newCachedThreadPool(new HandlerThreadFactory());
	exec.execute(new ExceptionThread2());
  }
}/*output:
concurrency.HandlerThreadFactory@5c647e05 creating new Thread
created Thread[Thread-0,5,main]
eh = concurrency.MyUncaughtExceptionHandler@33909752
run() by Thread[Thread-0,5,main]
eh = concurrency.MyUncaughtExceptionHandler@33909752
concurrency.HandlerThreadFactory@5c647e05 creating new Thread
created Thread[Thread-1,5,main]
eh = concurrency.MyUncaughtExceptionHandler@359d9ad4
caught java.lang.RuntimeException
*/

public class SettingDefaultHandler {
  public static void main(String[] args) {
	Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler());
	ExecutorService exec = Executors.newCachedThreadPool();
	exec.execute(new ExceptionThread());
  }
}