java多线程实现的方式及线程池使用

创建新执行线程有两种方法。
1，将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。通过创建该子类并调用start方法来实现
2，声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动，其中，接口的匿名内部类比较常用
3，线程池原理也就是一个Thread的集合

1，继承方式创建新线程(lang包下Thread)

*1.1，最基本的方式实现继承方式创建新线程

//继承父类
public class Thread01 extends Thread {
    @Override
    public void run() {
        //做你需要在新线程实现的代码
        System.out.println(Thread.currentThread());
        super.run();
    }
}

//使用方式：第一种方式开辟一条新的线程
Thread newThread = new Thread01();
 newThread.start();

• 1.2，使用匿名内部类实现继承方式创建新线程

Thread newThread02 = new Thread(){
    @Override
    public void run() {
        //做你需要在新线程实现的代码
        System.out.println("iooo");
        System.out.println(Thread.currentThread());
        super.run();
    }
};
newThread02.start();

2，实现接口方式创建新线程(lang包下Runnable)

• 2.1，最基本的方式实现接口方式创建新线程

//实现借口
public class Runnable01 implements Runnable {
    @Override
    public void run() {
        //你需要在新线程实现的代码
        System.out.println(Thread.currentThread());
    }
}

//使用方式：第二种方式开辟一条新的线程
Runnable01 runnable01 = new Runnable01();
new Thread(runnable01).start();

• 2.1，使用匿名内部类实现接口方式创建新的线程
  这种方式我不需要手动的创建一个类实现借口，可以直接使用匿名内部类进行创建，比较方便

//通过匿名内部类实现Runnable接口，并使用引用指向该接口实现
Runnable runnable02 = new Runnable(){
            @Override
            public void run() {
                //这里写你要在该新线程中执行的代码
                System.out.println(Thread.currentThread());
            }
        };

//使用方式：使用匿名内部类实现创建新的线程
new Thread(runnable02).start();

3，线程池使用(utils包下的子包concurrent包下的Executors工具类)

• 3.1，通过Runnable来传递任务到线程上，这种方式是没有返回值的，也不会影响主线程

//线程池的使用
//1，使用工厂类的静态方法创建一个线程对象，指定线程个数
ExecutorService executorService = Executors.newFixedThreadPool(2);
//2,通过传递Runnable来传递任务到线程上
executorService.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("这是线程池中的一个任务");
        System.out.println(Thread.currentThread());
    }
});
executorService.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("这是线程池中的第二任务");
        System.out.println(Thread.currentThread());
    }
});
executorService.submit(new Runnable() {
    @Override
    public void run() {
        System.out.println("这是线程池中的第三任务");
        System.out.println(Thread.currentThread());
    }
});

• 3.2，通过Callable传递任务到线程上， 有返回值，注意：这里是会阻塞主线程直到拿到返回结果。用Callable和直接在主线程执行的不同之处就是：这种创建新线程的方式可以同时执行多个任务，然后拿到结果，返回给主线程，然后主线程继续往下执行

ExecutorService executorService01 = Executors.newFixedThreadPool(3);
Future<String> future = executorService01.submit(new Callable<String>(){
    @Override
    public String call() throws Exception {
        System.out.println(Thread.currentThread());
        for (int i = 0; i < 200; i++) {
            System.out.println(i);
        }
        return "zhangdanfeng";
    }
});
String s = future.get();
System.out.println(s);
//注意：在拿到新线程任务的返回值之前，主线程是被阻塞的，所以下面的打印必定是在最后的
System.out.println("==============================");