Java 线程

• 1. extends Thread

package thread;

public class ThreadTest {

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }

    static class MyThread extends Thread {

        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.print(i + ",");
            }
            System.out.println();
            System.out.println("I'm gone.");
        }

    }
}

• 2 implements Runnable

package thread;

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

public class RunnableTest {

    public static void main(String[] args) {
        //way 1
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable1");
            }
        });
        thread.start();
        
        //way2
        ExecutorService pool = Executors.newCachedThreadPool();
        pool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable2");
            }
        });
        
    }
    
}

• 3 implements Callable
  通常利用ExecutorService的submit方法去启动call方法自执行任务，而ExecutorService的submit又返回一个Future类型的结果，因此Callable通常也与Future一起使用

package thread;

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;

public class CallableTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pool = Executors.newCachedThreadPool();
        Future<String> result = pool.submit(new Callable<String>() {

            @Override
            public String call() throws Exception {
                Thread.sleep(1500);
                return "done";
            }
        });
        System.out.println(result.get());
        System.out.println("exit");
        pool.shutdown();
    }

}

• 4 FutureTask(callable can get result, runnable can only get the result which you set before)

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService pools = Executors.newCachedThreadPool();
        FutureTask<String> task = new FutureTask<>(new Callable<String>() {

            @Override
            public String call() throws Exception {
                return "callable";
            }
        });
        pools.submit(task);
        System.out.println(task.get());

        FutureTask<String> task1 = new FutureTask<String>(new Runnable() {
            public void run() {

            }
        }, "done");
        pools.submit(task1);
        System.out.println(task1.get());
        
        pools.shutdown();
    }

}

• ps
  • wait()方法和notify()/notifyAll()方法在放弃对象监视器的时候的区别在于：wait()方法立即释放对象监视器，notify()/notifyAll()方法则会等待线程剩余代码执行完毕才会放弃对象监视器。
  • Thread.sleep(0)的作用: 当进程执行完毕或者自己主动挂起后，操作系统就会重新计算一 次所有进程的总优先级，然后再挑一个优先级最高的把 CPU 控制权交给他。