Thread myThread = new Thread();myThread.start();

public class MyThread extends Thread{ public void run(){ System.out.println(“do something”); }}

Thread myThread = new MyThread();myThread.start();

public class MyClass extends BaseDAO implements Runnable{ public MyClass(){ Thread thread = new Thread(this); thread.start(); } //实现run方法 public void run(){ System.out.println(“Do something cool here!”); }}

new Thread(){ public void run(){ System.out.println(“Do something cool here”); }}.start();

myThread.join();

myThread.sleep(1000);

public class Maze{ private int playerX; private int playerY; public synchronized boolean isAtExit(){ return (playerX == 0 && playerY == 0); } pubic synchronized void setPosition(int x, int y){ playerX = x; playerY = y; }}

public synchronized void setPosition(int x, int y){ playerX = x; playerY = Y;};

public void setPosition(int x , int y){ synchronized(this){ playerX = x; playerY = y; }}

Object myLock = new Object();…synchronized (myLock){ …}

public void myMethod(){ synchronized(this){ //下面是被同步的关键代码 } //下面是其它线程安全的代码}

public int square(int n){ int s = n * n; return s;}

  System.out.println(Thread.currentThread().getName());

//Thread Apublic void waitForMessage(){ while(hasMessage == false){ Thread.sleep(100); }}//Thread Bpublic void setMessage(String message){ … hasMessage = true;}

//Thread Apublic synchronized void waitForMessage(){ try{ wait(); }catch(InterruptedException ex){}}//Thread Bpublic synchronized void setMessage(String message){ … notify();}

wait(100);

ThreadPool myThreadPool = new ThreadPool(8);myThreadPool.runTask(new Runnable(){ public void run(){ System.out.println(“Do something cool here.”); }});myThreadPool.join();

import java.util.LinkedList;
/** 功能：一个线程池是一组有限数量的线程，它们被用来完成执行任务 翻写作者：技术大黍 备注： 线程池使用ThreadGroup API来实现.线程组表示一个线程的集合。 此外，线程组也可以包含其他线程组。线程组构成一棵树，在树中， 除了初始线程组外，每个线程组都有一个父线程组。允许线程访问 有关自己的线程组的信息，但是不允许它访问有关其线程组的父线 程组或其他任何线程组的信息。
*/public class ThreadPool extends ThreadGroup { private boolean isAlive; //表示线程是否活首 private LinkedList taskQueue; //定义一个双向队列 private int threadID; //保存线程的ID private static int threadPoolID; //表示线程池的ID
 /** 在构造方法创建线程池 @参数numThreads用来指定池中的线程个数 */ public ThreadPool(int numThreads) { super("线程池-" + (threadPoolID++)); setDaemon(true);//让该线程组为精灵线程组  isAlive = true;//设置初始值为true  taskQueue = new LinkedList();//初始化任务队列 for (int i=0; i<numThreads; i++) { new PooledThread().start();//启动池中的线程 } }

 /** 功能：请求一个新的任务来运行，该方法立即返回。然后任务在下一下空闲 的线程中执行。该方法是线程安全的。 <p>任务开始执行时有序的到达时开始。 @参数task表示运行的任务。如果不null,那么没有任务执行。 @如果本ThreadPool关闭了，那么抛出IllegalStateException。 */ public synchronized void runTask(Runnable task) { //如果线程池的状态isAlive==false值 if (!isAlive) { throw new IllegalStateException();//那么抛出异常 } //如果任务不为null if (task != null) { //那么在任务把该任务加入任务阶段 taskQueue.add(task); //然后唤醒空闲的线程执行该任务 notify(); }
 }
 /** 功能：获取任务对象 */ protected synchronized Runnable getTask() throws InterruptedException{ //如果任务队列不是空的 while (taskQueue.size() == 0) { //如果线程池的状态isAlive==false值 if (!isAlive) { return null; //那么返回null值 } wait();//否则等待任务出现(添加任务) } //否则任务队列中的一个任务对象 return (Runnable)taskQueue.removeFirst(); }

 /** 功能：关闭该线程池并且立即返回。让所有线程停止执行，并且所有等待任务停止执行。 一旦一个ThreadPool被关闭了，那么该线程池中的所有的线程不再运行。 */ public synchronized void close() { //如果线程池是活的 if (isAlive) { //那么置为false isAlive = false; //然后把任务队列清空 taskQueue.clear(); //最后终止线程池中所有线程的运行 interrupt(); } }

 /** 功能：关闭该ThreadPool活动,然后等待所有的线程运行完成。这样所有等待的任务会被执行。 */ public void join() { // 当ThreadPool不再活动时唤醒所有等待的线程 synchronized (this) { isAlive = false; notifyAll(); }  // 然后等待所有池中的线程对象执行完毕 Thread[] threads = new Thread[activeCount()]; //创建所有池中的活动线程 //把此线程组及其子组中的所有活动线程复制到指定数组中 int count = enumerate(threads); //然后按序让每个线程执行完毕 for (int i=0; i<count; i++) { try { threads[i].join(); } catch (InterruptedException ex) { } } }   /** 功能：定义线程池中的线程，这些线程对象用来运行任务对象(Runnables) 翻写作者：技术大黍 备注： PooledThread类是Thread类对象，它是一个内部类 */ private class PooledThread extends Thread {  public PooledThread() { //呼叫父类的构造方法Thread(ThreadGroup group, String name)， //把该线程分配指定的线程组对象中去 super(ThreadPool.this,"池中线程-" + (threadID++)); } //重写run方法，执行任务对象 public void run() { //如果本线程是没有断的--isInterrupted方法测试线程是否已经中断。线程的中断状态不受该方法的影响。 //对于isInterrupted方法，如果该线程已经中断，则返回 true；否则返回 false while (!isInterrupted()) { //那么从线程池中获取一个任务对象来执行 Runnable task = null; try { task = getTask(); }catch (InterruptedException ex){  ex.printStackTrace(); }
 //如果getTask()返回null或者被中断了，那么使用return语句来关闭该线程 // close this thread by returning. if (task == null) { return; }
 //否则执行任务对象,并且消除所有异常信息 try { task.run(); }catch (Throwable t) { //呼叫ThreadGroup类的静态方法处理异常 uncaughtException(this, t); } } } }}

import static java.lang.System.*;/** 功能：书写一个测试类线程池的类 作者：技术大黍 */public class ThreadPoolTest {  public static void main(String[] args) { if (args.length != 2) { out.println("测试ThreadPool（线程池）任务."); out.println( "使用方法: java ThreadPoolTest 任务数 线程数"); out.println( " 任务数 - integer: 表示需要执行的任务数量."); out.println( " 线程数 - integer: 表示在线程池中的线程的数量 "); return; } //读取命令行参数任务数值和线程数值 int numTasks = Integer.parseInt(args[0]); int numThreads = Integer.parseInt(args[1]);  //创建线程池对象 ThreadPool threadPool = new ThreadPool(numThreads);  //执行示例任务 for (int i = 0; i < numTasks; i++) { threadPool.runTask(createTask(i)); }  //关闭线程池以等待所有线程完毕 threadPool.join(); }   /** 功能：创建简单Runnable对象用来每隔500毫秒打印ID */ private static Runnable createTask(final int taskID) { return new Runnable() { public void run() { out.println("任务 " + taskID + ": 开始");  //模拟长时间执行任务 try { Thread.sleep(500); }catch (InterruptedException ex) {  ex.printStackTrace(); } out.println("任务 " + taskID + ": 结束"); } }; }}

import java.util.*;import java.util.concurrent.*;/** * 功能：书写一个测试类，用来演示ForkJoinPool类的用法。 * 作者：技术大黍 */
public class ForkJoinPoolTest { public static void main(String[] args) { //创建线程池对象 ForkJoinPool pool = new ForkJoinPool(); IntSum task = new IntSum(3); long sum = pool.invoke(task); System.out.println("Sum is " + sum); }}/** * 功能：书写需要被并发计算整数的类 */class IntSum extends RecursiveTask<Long> { private int count; public IntSum(int count) { this.count = count; }
 @Override protected Long compute() { long result = 0;
 if (this.count <= 0) { return 0L;  }else if (this.count == 1) { return (long) this.getRandomInteger(); } List<RecursiveTask<Long>> forks = new ArrayList<>(); for (int i = 0; i < this.count; i++) { IntSum subTask = new IntSum(1); subTask.fork(); // 启动子任务 forks.add(subTask); } // 所有子任务完成并且组成一个结果 for (RecursiveTask<Long> subTask : forks) { result = result + subTask.join(); } return result; }
 public int getRandomInteger() { return 2; }}

import java.util.concurrent.*;
/** * 功能：书写一个Excutors类实现线程池的示例  * 作者：技术大黍 */public class ExcutorsTest { public static void main(String[] args) { final int THREAD_COUNT = 3; final int LOOP_COUNT = 3; final int TASK_COUNT = 5;
 // 从线程池中获取一个执行器对象 ExecutorService exec = Executors.newFixedThreadPool(THREAD_COUNT);
 // 创建5个任务对象，然后把它们放到执行器中去 for (int i = 1; i <= TASK_COUNT; i++) { RunnableTask task = new RunnableTask(i, LOOP_COUNT); exec.submit(task); } exec.shutdown(); }}
/** * 功能：书写一个被线程池执行的任务对象 */class RunnableTask implements Runnable { private int taskId; private int loopCounter;
 public RunnableTask(int taskId, int loopCounter) { this.taskId = taskId; this.loopCounter = loopCounter; }
 public void run() { for (int i = 1; i <= loopCounter; i++) { try { System.out.println("Task #" + this.taskId + " - Iteration #" + i); Thread.sleep(1000); } catch (Exception e) { System.out.println("Task #" + this.taskId + " has been interrupted."); break; } } }}