java中线程-线程池常用的构建方式

一、三种创建方式

二、通过Thread类创建
1、自定义线程类继承Thread类
2、重写run()方法，编写线程执行体
3、创建线程对象，调用start()方法启动线程

1.直接新建类，并继承Thread类
//主方法
public class Demo01 {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();
        thread1.start();
        thread2.start();
    }
}
//100以内的偶数
class Thread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2==0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
//100以内的奇数
class Thread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%2!=0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
2.通过匿名方法实现（线程用过以后就不再用了）
public class Demo02 {
    public static void main(String[] args) {
        //打印0~100内的偶数
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i%2==0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
        //打印0~100内的奇数
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    if (i%2!=0){
                        System.out.println(Thread.currentThread().getName() + ":" + i);
                    }
                }
            }
        }.start();
    }
}

三、Thread类中常用的方法

start()启动当前线程；调用当前线程的run()方法
run()：通常需要重写Thread类中的此方法，将创建线程需要执行的操作声明在此方法中（当做main()使用）
currentThread()：静态方法，返回执行当前代码的线程
getName()：获取当前线程的名字
setName(String name)：设置当前线程的名字
yield()：释放当前CPU的执行权（但也有可能下一刻的执行权又回到了当前线程，主控权还是在CPU手上）
join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b完全执行完之后，线程a在结束阻塞状态（可保证线程按指定顺序执行，通过阻塞得方式）
stop()：当执行此方法时，强制结束当前线程（已停用）
sleep(int millitime)：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前进程是阻塞状态
isAlive()：判断当前线程是否存活（线程执行完之前都是存活的）

四、通过实现Runnable接口来创建线程
1.创建一个实现了Runnable接口的类
2.实现类去实现Runnable接口中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
6.这里的start()首先启动了当前的线程，然后调用了Runnable类型的target的run()

五、继承Thread类和实现Runnable接口两种方式比较

开发中，优先选择实现Runnable接口的方式创建线程
原因：实现Runnable接口的方式没有类的单继承性的局限性（一个类只能继承一个父类，继承了Thread类就不能在继承其他类了）
实现Runnable接口的方式更适合来处理多个线程之间有共享数据的情况
联系：Thread类本身也实现了Runnable接口

相同点：两种方式都需要重写run()方法，将线程要执行的逻辑声明在run()方法中

线程按指定顺序执行示例：

public class JoinTest2 {
	// 1.现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行
	public static void main(String[] args) {
		final Thread t1 = new Thread(new Runnable() {
			@Override public void run() {
				System.out.println("t1");
			}
		});
		final Thread t2 = new Thread(new Runnable() {
			@Override public void run() {
				try {
					// 引用t1线程，等待t1线程执行完 
                    t1.join(); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
                S ystem.out.println("t2"); 
            } 
        }); 
        Thread t3 = new Thread(new Runnable() { 
            @Override public void run() { 
                try { 
                    // 引用t2线程，等待t2线程执行完 
                    t2.join(); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
                S ystem.out.println("t3");
            } 
        }); 
        t3.start();//这里三个线程的启动顺序可以任意，大家可以试下！ 
        t2.start(); 
        t1.start(); 
    } 
}

六、实现Callable接口
步骤：
1、创建一个实现Callable的实现类
2、实现call方法，将此线程需要执行的操作声明在call()中
3、创建Callable接口实现类的对象
4、将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6、获取Callable中call方法的返回值
实现Callable接口的方式创建线程的强大之处
1、call()可以有返回值的
2、call()可以抛出异常，被外面的操作捕获，获取异常的信息
3、Callable是支持泛型的

示例一：
package com.atguigu.java2;

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

//1.创建一个实现Callable的实现类
class NumThread implements Callable {
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        //把100以内的偶数相加
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {    
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(futureTask).start();
        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

输出结果：
92
94
96
98
100
总和为：2550

示例二：
package com.jian8.juc.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable come in");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 1024;
    }
}

public class CallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //使用构造方法：FutureTask(Callable<V> callable)
        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread());
        new Thread(futureTask, "AAA").start();
        //new Thread(futureTask, "BBB").start();//复用，直接取值，不要重启两个线程
        //PS：多个线程来抢一个futureTask，里面的计算方法call()只计算一次，要想多次算，要创建多个FutureTask<V>对象
        int a = 100;
        int b = 0;
        //b = futureTask.get();//要求获得Callable线程的计算结果，如果没有计算完成就要去强求，会导致堵塞，直到计算完成
        while (!futureTask.isDone()) {//当futureTask完成后取值
            b = futureTask.get();
        }
        System.out.println("Result=" + (a + b));
    }
}

输出结果：
Callable come in
Result=1124

什么是线程池（英文：Thread Pool）:
线程池是一种多线程处理形式，处理过程中将任务添加到队列中，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件），则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的任务，则线程池将在一段时间后创建另一个辅助线程，但线程的总数永远不会超过最大值。超过最大值的线程可以排队，但它们要等到其他线程完成后才启动。
线程池的伸缩性对性能的影响：

• 创建太多线程，将会浪费一定的资源，有些线程未被充分利用
• 销毁太多线程，将导致之后浪费时间再次创建它们
• 创建线程太慢，将会导致长时间的等待，性能变差
• 销毁线程太慢，导致其他线程资源饥饿

线程池的组成部分：

1. 线程池管理器（ThreadPoolManager）:用于创建并管理线程池
2. 工作线程（WorkThread）:线程池中线程
3. 任务接口（Task）:每个任务必须实现的接口，以供工作线程调度任务的执行
4. 任务队列:用于存放没有处理的任务，提供一种缓冲机制

构建线程池常用的方法：

1. newFixedThreadPool() 创建固定个数的线程池
2. newSingleThreadExecutor() 只创建一个线程的线程池
3. newCachedThreadPool() 创建一个可变个数的线程池
4. newSingleThreadScheduledExecutor() 线程池个数为1
5. newScheduledThreadPool(10) 可指定线程池的个数

举例如下所示：

public static void main(String[] args) {
		//7线程池的创建                                                                                                       ExecutorService                                ScheduledExecutorService
//		接口:Executor-> ExecutorService-> ScheduledExecutorService 实现类:AbstractExecutorService-> ThreadPoolExecutor-> ScheduledThreadPoolExecutor
		//线程池创建的常用几种方式
		/*
		 * 1.newFixedThreadPool() 创建固定个数的线程池
		 * 2.newSingleThreadExecutor() 只创建一个线程的线程池
		 * 3.newCachedThreadPool() 创建一个可变个数的线程池
		 * 4.newSingleThreadScheduledExecutor() 线程池个数为1
		 * 5.newScheduledThreadPool() 可指定线程池的个数
		 */
		
		ExecutorService es=Executors.newFixedThreadPool(5);
//		Executors.newSingleThreadExecutor();
//		Executors.newCachedThreadPool();
//		Executors.newSingleThreadScheduledExecutor();
//		Executors.newScheduledThreadPool(10);
		for(int i=0;i<5;i++){
			es.execute(new Runnable(){
				public void run(){
					System.out.println("ThreadID:"+Thread.currentThread().getId());
				}
			});
		}
		
	}

输出结果如下：

ThreadID:11
ThreadID:10
ThreadID:9
ThreadID:12
ThreadID:13