java 创建线程的四种方式

package Threads;

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

/// 实现线程同步：synchronized 同步代码块，同步方法，lock锁
/// 死锁：资源互斥，请求保持，不可剥夺，循环依赖 ；处理死锁需要破坏其中之一条件，预防死锁需要考虑资源分配问题（银行家算法...）
// wait 和 sleep 区别;
//      - sleep为线程内部暂停，不会释放锁；
//      - wait应用与线程间的通信，会释放锁。
//      - wait 需要唤醒 notify，或者使用 notifyAll，sleep到时间自动恢复就绪状态
//      - 两者都会使线程处于阻塞状态
/**
 * 创建线程的四种方式
 * */
public class WaysOfCreatThreads {
    public static void main(String[] args) {
        // 继承Thread类
        new MyThread().start();
        // 实现Runnable接口（优点：可以多实现，突破继承Thread类方法的单继承局限性）
        new Thread(new MyRunnable()).start();
        // 实现Callable接口（优点：可以有返回值，支持泛型，能抛异常，需要借助Future方法）
        new Thread(new FutureTask<>(new MyCallable<Integer>())).start();
        // JDK线程池（减小cpu开销，提高响应速度，便于线程的管理）
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new MyRunnable());
        service.submit(new MyCallable<Integer>());
        // 需要shutdown，不然一直处于运行状态
        service.shutdown();
    }

    private static class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("Thread");
        }
    }

    private static class MyRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("Runnable");
        }
    }

    private static class MyCallable<Integer> implements Callable<java.lang.Integer> {
        @Override
        public java.lang.Integer call() throws Exception {
            System.out.println("Callable");
            int a = 10;
            return a;
        }
    }
}