public class ThreadTest extends Thread {   
    public void run() {   
        // 在这里编写线程执行的主体   
        // do something   
    }   
}  

public class RunnableTest implements Runnable {   
    public void run() {   
        // 在这里编写线程执行的主体   
        // do something   
    }   
}  

public class ThreadStartTest {   
    public static void main(String[] args) {   
        // 创建一个线程实例   
        ThreadTest tt = new ThreadTest();   
        // 启动线程   
        tt.start();   
    }   
}  

public class RunnableStartTest {   
    public static void main(String[] args) {   
        // 创建一个线程实例   
        Thread t = new Thread(new RunnableTest());   
        // 启动线程   
        t.start();   
    }   
}  

public void run() {   
    if (target != null) {   
        target.run();   
    }   
}  

public enum State {   
    NEW,   
    RUNNABLE,   
    BLOCKED,   
    WAITING,   
    TIMED_WAITING,   
    TERMINATED;   
}  

public static native void sleep(long millis) throws InterruptedException;   
  
public static void sleep(long millis, int nanos) throws InterruptedException {        
    //other code   
}

public class InterruptTest {   
    public static void main(String[] args) {   
        Thread t = new Thread() {   
            public void run() {   
                try {   
                    System.out.println("我被执行了-在sleep()方法前");   
                    // 停止运行10分钟   
                    Thread.sleep(1000 * 60 * 60 * 10);   
                    System.out.println("我被执行了-在sleep()方法后");   
                } catch (InterruptedException e) {   
                    System.out.println("我被执行了-在catch语句块中");   
                }   
                System.out.println("我被执行了-在try{}语句块后");   
            }   
        };   
        // 启动线程   
        t.start();   
        // 在sleep()结束前中断它   
        t.interrupt();   
    }   
}  

public final void wait() throws InterruptedException {   
    //do something   
}   
  
public final native void wait(long timeout) throws InterruptedException;   
  
public final void wait(long timeout, int nanos) throws InterruptedException {   
    //do something   
}  

public synchronized void aMethod() {   
    // do something   
}   
  
public static synchronized void anotherMethod() {   
    // do something   
}  

public void test() {   
    // 同步锁   
    String lock = "LOCK";   
  
    // 同步块   
    synchronized (lock) {   
        // do something   
    }   
  
    int i = 0;   
    // ...   
}  

private Lock lock = new ReentrantLock();   
  
public void testLock() {   
    // 锁定对象   
    lock.lock();   
    try {   
        // do something   
    } finally {   
        // 释放对对象的锁定   
        lock.unlock();   
    }   
}  

public abstract class Task {   
    public enum State {   
        /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED   
    }   
  
    // 任务状态   
    private State state = State.NEW;   
  
    public void setState(State state) {   
        this.state = state;   
    }   
  
    public State getState() {   
        return state;   
    }   
  
    public abstract void deal();   
}  

import java.util.Iterator;   
import java.util.LinkedList;   
import java.util.List;   
  
public class TaskQueue {   
    private List<Task> queue = new LinkedList<Task>();   
  
    // 添加一项任务   
    public synchronized void addTask(Task task) {   
        if (task != null) {   
            queue.add(task);   
        }   
    }   
  
    // 完成任务后将它从任务队列中删除   
    public synchronized void finishTask(Task task) {   
        if (task != null) {   
            task.setState(Task.State.FINISHED);   
            queue.remove(task);   
        }   
    }   
  
    // 取得一项待执行任务   
    public synchronized Task getTask() {   
        Iterator<Task> it = queue.iterator();   
        Task task;   
        while (it.hasNext()) {   
            task = it.next();   
            // 寻找一个新建的任务   
            if (Task.State.NEW.equals(task.getState())) {   
                // 把任务状态置为运行中   
                task.setState(Task.State.RUNNING);   
                return task;   
            }   
        }   
        return null;   
    }   
}  

public class TaskThread extends Thread {   
    // 该线程所属的线程池   
    private ThreadPoolService service;   
  
    public TaskThread(ThreadPoolService tps) {   
        service = tps;   
    }   
  
    public void run() {   
        // 在线程池运行的状态下执行任务队列中的任务   
        while (service.isRunning()) {   
            TaskQueue queue = service.getTaskQueue();   
            Task task = queue.getTask();   
            if (task != null) {   
                task.deal();   
            }   
            queue.finishTask(task);   
        }   
    }   
}  

import java.util.ArrayList;   
import java.util.List;   
  
public class ThreadPoolService {   
    // 线程数   
    public static final int THREAD_COUNT = 5;   
  
    // 线程池状态   
    private Status status = Status.NEW;   
  
    private TaskQueue queue = new TaskQueue();   
  
    public enum Status {   
        /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,   
    }   
  
    private List<Thread> threads = new ArrayList<Thread>();   
  
    public ThreadPoolService() {   
        for (int i = 0; i < THREAD_COUNT; i++) {   
            Thread t = new TaskThread(this);   
            threads.add(t);   
        }   
    }   
  
    // 启动服务   
    public void start() {   
        this.status = Status.RUNNING;   
        for (int i = 0; i < THREAD_COUNT; i++) {   
            threads.get(i).start();   
        }   
    }   
  
    // 停止服务   
    public void stop() {   
        this.status = Status.TERMINATED;   
    }   
  
    // 是否正在运行   
    public boolean isRunning() {   
        return status == Status.RUNNING;   
    }   
  
    // 执行任务   
    public void runTask(Task task) {   
        queue.addTask(task);   
    }   
  
    protected TaskQueue getTaskQueue() {   
        return queue;   
    }   
}  

public class SimpleTaskTest extends Task {   
    @Override  
    public void deal() {   
        // do something   
    }   
  
    public static void main(String[] args) throws InterruptedException {   
        ThreadPoolService service = new ThreadPoolService();   
        service.start();   
        // 执行十次任务   
        for (int i = 0; i < 10; i++) {   
            service.runTask(new SimpleTaskTest());   
        }   
        // 睡眠1秒钟，等待所有任务执行完毕   
        Thread.sleep(1000);   
        service.stop();   
    }   
}  

public static ExecutorService newCachedThreadPool() {   
    // other code   
}   
  
public static ExecutorService newFixedThreadPool(int nThreads) {   
    // other code   
}   
  
public static ExecutorService newSingleThreadExecutor() {   
    // other code   
}  

import java.util.concurrent.*;   
  
public class ExecutorTest {   
    public static void main(String[] args) throws InterruptedException,   
            ExecutionException {   
        ExecutorService es = Executors.newSingleThreadExecutor();   
        Future fr = es.submit(new RunnableTest());// 提交任务   
  
        Future fc = es.submit(new CallableTest());// 提交任务   
        // 取得返回值并输出   
        System.out.println((String) fc.get());   
  
        // 检查任务是否执行完毕   
        if (fr.isDone()) {   
            System.out.println("执行完毕-RunnableTest.run()");   
        } else {   
            System.out.println("未执行完-RunnableTest.run()");   
        }   
  
        // 检查任务是否执行完毕   
        if (fc.isDone()) {   
            System.out.println("执行完毕-CallableTest.run()");   
        } else {   
            System.out.println("未执行完-CallableTest.run()");   
        }   
  
        // 停止线程池服务   
        es.shutdown();   
    }   
}   
  
class RunnableTest implements Runnable {   
    public void run() {   
        System.out.println("已经执行-RunnableTest.run()");   
    }   
}   
  
class CallableTest implements Callable {   
    public Object call() {   
        System.out.println("已经执行-CallableTest.call()");   
        return "返回值-CallableTest.call()";   
    }   
}