多线程..

线程定义：线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中实际运作单位。简单来说，应用软件中相互独立，可以同时运作的功能。

多线程作用：有了多线程，我们就可以让程序同时做多件事情。

应用场景：只要你想让多个事件同时运行就需要用到多线程。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并行：在同一时刻，有多个指令在多个CPU上同时执行。

多线程的实现方式

1.继承Thread类的方式进行执行

步骤：

自己定义一个类继承Thread

重写run方法

创建子类的对象，并启动线程。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("Hello");
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	//创建子类对象，开启线程
    	MyThread mt=new MyThread();
    	mt.start();
	 }
}

2.实现Runnable接口的方式进行实现

步骤：

自己定义一个类实现Runnable接口

重写里面的run方法

创建自己类的对象

创建一个Thread类的对象，并开启线程。

public class MyThread implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("world");
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	//创建自己类的对象
    	MyThread mt=new MyThread();
    	//创建Thread对象，并开启线程
    	Thread t=new Thread(mt);
    	t.start();
	 }
}

若想看看两个线程的相互执行，获取线程的名字：

public class MyThread implements Runnable{
	//在此获取线程的名字
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
		Thread t=Thread.currentThread();//获取当前线程对象
		System.out.println(t.getName()+":world");
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	//创建自己类的对象
    	MyThread mt=new MyThread();
    	//创建Thread对象，并开启线程
    	Thread t1=new Thread(mt);
    	Thread t2=new Thread(mt);
    	//给线程设置名字
    	t1.setName("线程1");
    	t2.setName("线程2");
    	t1.start();
    	t2.start();
	 }
}

3.利用Callable接口和Future接口方式实现

特点：可以获取多线程运行的结果。

1）创建一个MyCallable类实现Callable接口；

2）重写call方法（是有返回值的，表示多线程运行的结果）；

3）创建MyCallable的对象（表示多线程要执行的任务）；

4）创建FutureTask的对象（作用管理多线程的运行结果）；

5）创建Thread类的对象，并启动（表示线程）。

public class MyCallable implements Callable<Integer>{
    //计算1~10的和
	@Override
	public Integer call() throws Exception {
		int sum=0;
		for(int i=0;i<=10;i++) {
			sum+=i;
		}
		return sum;
	}

}

public class test {
    public static void main(String [] args) throws InterruptedException, ExecutionException  {
    	MyCallable mc=new MyCallable();
    	FutureTask<Integer> ft=new FutureTask<>(mc);//管理多线程运行结果
    	Thread t=new Thread(ft);
    	t.start();//开启线程
    	//获取返回值
         Integer sum=ft.get();
         System.out.println(sum);
	 }
}

多线程的成员方法

获取与设置线程的名字

注：若我们未给线程设置名字，线程也有默认的名字，格式：Thread-X（X为序号，从0开始）。

若我们要给线程设置名字，可以用set方法，也可以用构造方法（调用父类的构造方法）设置。

1）用set进行设置。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			//获取线程名字
			System.out.println(getName()+":"+i);
		}
	}

}

public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	//设置线程名字，用set方法设置
    	t1.setName("线程1");
    	t2.setName("线程2");
    	t1.start();
    	t2.start();
	 }
}

线程之间交替运行。

2）用构造方法进行设置

public class MyThread extends Thread{
	public MyThread() {//调用父类的构造方法
		
	}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println(getName()+":"+i);
		}
	}

}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread("飞机");
    	MyThread t2=new MyThread("鼠标");
    	t1.start();
    	t2.start();
	 }
}

线程休眠

static void sleep(long time)——让线程休眠指定时间，单位毫秒。

注：哪条线程执行到这个方法，那么哪条线程就会在这停留对应的时间。当时间到了之后，线程会自动醒来，执行下面的代码。

public class MyThread extends Thread{
	public MyThread() {//调用父类的构造方法
		
	}
	public MyThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			try {
				Thread.sleep(1000);//每个一秒打印一个数据
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(getName()+":"+i);
		}
	}

}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread("飞机");
    	MyThread t2=new MyThread("鼠标");
    	t1.start();
    	t2.start();
	 }
}

线程的优先级

在java中使用抢占式调度，其特点为随机性。优先级为1~10，默认优先级为5，优先级越高，抢到CPU的概率越大，但并不是百分之一百抢到CPU。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<7;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	//设置线程名字
    	t1.setName("键盘");
    	t2.setName("鼠标");
    	//设置线程的优先级
    	t1.setPriority(1);
    	t2.setPriority(10);
    	t1.start();
    	t2.start();
	 }
}

鼠标优先级大，鼠标先执行完毕。

守护线程

当其他非守护线程结束后，守护线程也会陆续结束（一般不会执行完毕）。

public class MyThread1 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<8;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class MyThread2 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread1 t1=new MyThread1();
    	MyThread2 t2=new MyThread2();
    	//设置线程名字
    	t1.setName("线程");
    	t2.setName("备份");
    	//将t2设置为守护线程
    	t2.setDaemon(true);
    	t1.start();
    	t2.start();
	 }
}

礼让线程

礼让线程也叫出让线程，作用：尽可能使结果均匀一点。

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<8;i++) {
			System.out.println(getName()+":"+i);
			Thread.yield();//出让线程
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	//设置线程名字
    	t1.setName("线程1");
    	t2.setName("线程2");
    	
    	t1.start();
    	t2.start();
	 }
}

插入线程

public class MyThread extends Thread{
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println(getName()+":"+i);
		}
	}
}
public class test {
    public static void main(String [] args) throws InterruptedException  {
    	MyThread t1=new MyThread();	
    	t1.setName("土豆");
    	t1.start();
    	t1.join();//插入线程，将土豆线程插入到main线程之前
    	for(int i=0;i<10;i++) {
    		System.out.println("main线程"+i);
    	}
	 }
}

线程的生命周期

同步代码块

把操作共享的代码锁起来。

锁对象一定要求是唯一的。

利用同步代码块可解决线程安全问题。若没有锁，可能会出现数据重复，数据超出要求的范围等等问题。

练习

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。

public class MyThread extends Thread{
	//设置一个静态数据，表示这个类所有对象可以共享
	  static int ticket=0;//票数
	  static Object obj=new Object();//锁对象一定要是唯一的
	@Override
	public void run() {
		while(true) {
			synchronized(obj) {
			if(ticket<100) {
				try {
					Thread.sleep(100);//数据慢慢的输出
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				ticket++;
				System.out.println(getName()+"今天卖出第"+ticket+"票");
			}else {
				break;
			}
			}
		}
	}
}
public class test {
    public static void main(String [] args)  {
    	MyThread t1=new MyThread();
    	MyThread t2=new MyThread();
    	MyThread t3=new MyThread();
    	//设置名字
    	t1.setName("窗口1");
    	t2.setName("窗口2");
    	t3.setName("窗口3");
    	t1.start();
    	t2.start();
    	t3.start();
	 }
}

同步方法

就是把synchronized关键字加到方法上。

同步方法是用同步代码块提取方法，改编而来的。

练习

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。（使用同步方法完成，技巧：先构建好同步代码块，在进行变换）

public class MyThread implements Runnable{//使用第二种方法
    int ticket=0;//使用第二种方法创建对象，不用设置这个为静态的
    @Override
    public void run() {
        while(true) {       
                if (mehod()) break;         
        }

    }
    private synchronized boolean mehod() {//同步方法
        if(ticket==100) {
            return true;
        }else {
            try {
                Thread.sleep(100);//若想要看到多个线程交织进行，可采用sleep让线程睡一会
            } catch (final InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            ticket++;
            System.out.println(Thread.currentThread().getName()+"今天卖了第"+ticket+"张票");
        }
        return false;
    }


}

public class test1 {
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        Thread t1=new Thread(mt);
        Thread t2=new Thread(mt);
        Thread t3=new Thread(mt);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

Lock锁

练习

某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票。（利用Lock锁进行）

在Lock锁当中利用try-catch-finall来进行开锁关锁。，将while循环中的主体程序写完之后，从获得锁开始后利用快捷方法生成try-catch-finall，finally中写释放锁。

public class MyThread extends Thread{
    //设置一个静态数据，表示这个类所有对象可以共享
    static int ticket=0;
    Lock lock=new ReentrantLock();//创建一个锁对象
    @Override
    public void run() {
        while(true) {
          //  synchronized (MyThread.class) {
            lock.lock();//获得锁
            try {
                if (ticket < 100) {
                        Thread.sleep(100);//数据慢慢的输出
                    ticket++;
                    System.out.println(getName() + "今天卖出第" + ticket + "票");
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } finally {
                lock.unlock();//释放锁
            }
            // }
        }
    }
}

public class test1 {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        //设置名字
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
    }

书写进程步骤：

生产者和消费者（等待唤醒机制）

生产者消费者模式是一个十分经典的多线程协作的模式。

例如：吃货和厨师（消费者和生产者）

常见方法：

实现方法1：基本方法

有：生产者、消费者、控制生产者和消费者的代码

先写中间：

public class Desk {//中间变量
    //作用：控制消费者和生产者的代码
    //定义桌子状态，0无面条，1有面条
    public static int state=0;
    //定义吃货最大能吃多少,总个数
    public static int count=10;
    //定义锁对象
    public static Object lock=new Object();
}

消费者：

public class Eat extends Thread{//消费者
    //循环
    //同步代码块（同步方法，锁方法均可）
    //判断共享数据是否到末尾（先写到了末尾，再写未到末尾）
    @Override
    public void run(){
        while(true){
            synchronized (Desk.lock){//锁对象
                //判断共享数据是否到末尾
                if(Desk.count==0){
                    break;
                }else{
                    //先判断桌子上物品状态
                    if(Desk.state==0){
                        //如果没有消费者等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //如果有
                        Desk.count--;
                        System.out.println("这个人还能再吃"+Desk.count+"碗饭");
                        //吃完唤醒厨师继续做
                        Desk.lock.notifyAll();
                        //修改桌子状态
                        Desk.state=0;
                    }

                }
            }
        }
    }
}

生产者：

public class Cook extends Thread{//生产者
    @Override
    public void run(){
        while(true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    //判断桌子状态
                    if(Desk.state==1){
                        //如果有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }else{
                        //如果没有
                        System.out.println("厨师做了一碗面");
                        //修改桌子状态
                        Desk.state=1;
                        //唤醒消费者
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}

测试类：

public class test1 {
    public static void main(String[] args) {
        Cook c=new Cook();
        Eat e=new Eat();
        //设置名字
        c.setName("厨师：");
        e.setName("吃货");
        //开启线程
        c.start();
        e.start();
    }
    }

实现方法2：阻塞队列方法实现

阻塞队列的接口和实现类：

public class Cook extends Thread{//生产者
    ArrayBlockingQueue<String> queue;

    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue=queue;
    }

    @Override
    public void run(){
        while(true){
            //调用阻塞队列将面条放入
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
public class Eat extends Thread{//消费者
    ArrayBlockingQueue<String> queue;

    public Eat(ArrayBlockingQueue<String> queue) {
        this.queue=queue;
    }

    @Override
    public void run(){
        while(true){
            try {
                String food=queue.take();
                System.out.println(food);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }


        }
    }
}
public class test1 {
    public static void main(String[] args) {
      //创建阻塞队列
        ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(10);//定义阻塞队列中的队列长度
        Cook c=new Cook(queue);
        Eat e=new Eat(queue);
        c.setName("厨师");
        e.setName("吃货");
        c.start();
        e.start();
    }
    }

线程的六种状态

综合练习

练习1：抢红包

（因为获取Double类型的随机数只能在JDK17中，抢红包实际抢到的是小数，在此题下理想化，认为是整数）
抢红包也用到了多线程。假设: 100块，分成了3个包，现在有5个人去抢。其中，红包是共享数据。5个人是5条线程。
打印结果如下:
XXX抢到了XXX元
XXX抢到了XXX元
XXX抢到了XXX元
XXX没抢到
XXX没抢到

package test1;
import java.util.Random;
public class MyThread extends  Thread{
    //定义静态变量
    static  int money=100;//总金额
    static int count=3;//红包个数
    static final int MIN=1;//抢到的金额的最小值
    @Override
    public void run() {
        synchronized (MyThread.class) {
            //判断金额
            if (money == 0) {
                System.out.println(getName() + "没有抢到红包");
            } else {
                //判断红包个数
                int prize = 0;//中奖金额
                if (count == 1) {
                    //只剩一个红包，中奖金额就是余额
                    prize = money;
                } else {
                    //进行随机数，获取红包金额
                    Random r = new Random();
                    int bound = money - (count - 1) * MIN;
                    prize = r.nextInt(bound);
                    if (prize < MIN) {
                        prize = MIN;
                    }
                }
                money = money - prize;
                count--;
                System.out.println(getName() + "抢到了" + prize + "元");
            }
        }
    }
}

public class test1 {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        MyThread t2=new MyThread();
        MyThread t3=new MyThread();
        MyThread t4=new MyThread();
        MyThread t5=new MyThread();
        t1.setName("张三");
        t2.setName("李四");
        t3.setName("王五");
        t4.setName("赵六");
        t5.setName("导航");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
    }
    }

练习2：抽奖池抽奖

有一个抽奖池，该抽奖池中存放了奖励的金额，该抽奖池中的奖项为{10,5,20,50,100,200,500,800,2,80,300,700};
创建两个抽奖箱(线程)设置线程名称分别为“ 抽奖箱1”，‘ '抽奖箱2”随机从抽奖池中获取奖项元素并打印在控制台上格式如下:
每次抽出一个奖项就打印一个(随机)
抽奖箱1又产生了一个10元大奖
抽奖箱1又产生了一个100元大奖
抽奖箱2又产生了一个700元大奖
分析：可用集合和数组进行，但数组去重比较复杂，利用集合完成。

public class MyThread extends  Thread {
    ArrayList<Integer> list;//静态变量

    //可以利用构造方法
    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (MyThread.class) {
                if (list.size() == 0) {
                    break;
                } else {
                    Collections.shuffle(list);//打乱list数据
                    int prize = list.remove(0);
                    System.out.println(getName() + "又产生了一个" + prize + "大奖");
                }
            }
            try {
                Thread.sleep(100);//目的是可以让两个线程交替进行显示
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

public class test1 {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyThread t1=new MyThread(list);
        MyThread t2=new MyThread(list);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
    }
    }

练习3：多线程统计并求最大值

在上一题基础上继续完成如下需求:
每次抽的过程中，不打印，抽完时一次性打印(随机)，在此次抽奖过程中，抽奖箱1总共产生了6个奖项。
分别为: 10,20,100,500,2,300最高奖项为300元，总计额为932元在此次抽奖过程中，抽奖箱2总共产生了6个奖项。
分别为: 5, 50,200,800,80,700最高奖项为800元，总计额为1835元

解法一：对第一个程序进行改编

public class MyThread extends  Thread{
    ArrayList<Integer> list;//静态变量
    //可以利用构造方法
    public MyThread(ArrayList<Integer> list){
        this.list=list;
    }
    //创建两个集合来存放数据
    static  ArrayList<Integer> list1=new ArrayList<>();
   static ArrayList<Integer> list2=new ArrayList<>();
    @Override
    public void run(){
        while(true){
          synchronized (MyThread.class) {
            if(list.size()==0){
                if("抽奖箱1".equals(getName())){
                    System.out.println("抽奖箱1"+list1);
                    int max=0;
                    int count=0;
                    for(int i=0;i<list1.size();i++){
                        if(max<= list1.get(i)){
                            max=list1.get(i);
                        }
                        count+=list1.get(i);
                    }
                    System.out.println("抽奖箱1最大奖"+max);
                    System.out.println("抽奖箱1总计"+count);
                }else if("抽奖箱2".equals(getName())) {
                    System.out.println("抽奖箱2"+list2);
                    int max=0;
                    int count=0;
                    for(int i=0;i<list2.size();i++){
                        if(max<= list2.get(i)){
                            max=list2.get(i);
                        }
                        count+=list2.get(i);
                    }
                    System.out.println("抽奖箱2最大奖"+max);
                    System.out.println("抽奖箱2总计"+count);
                }
                break;
            }else{
                Collections.shuffle(list);//打乱list数据
                int prize=list.remove(0);
               //进行判断
                if("抽奖箱1".equals(getName())){
                    list1.add(prize);
                }else if("抽奖箱2".equals(getName())){
                    list2.add(prize);
                }
            }
        }
}
        try {
            Thread.sleep(10);//目的是可以让两个线程交替进行显示
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

解法二：线程栈

public class MyThread extends  Thread {
    ArrayList<Integer> list;//静态变量

    //可以利用构造方法
    public MyThread(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        ArrayList<Integer> List=new ArrayList<>();
        while (true) {
            synchronized (MyThread.class) {
                if (list.size() == 0) {
                    System.out.println(getName()+List);
                    break;
                } else {
                    Collections.shuffle(list);//打乱list数据
                    int prize = list.remove(0);
                    List.add(prize);
                }
            }
            try {
                Thread.sleep(100);//目的是可以让两个线程交替进行显示
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

        }
    }
}

练习4：多线程之间的比较

在上一题基础上继续完成如下需求:在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为: 10,20,100,500,2,300，最高奖项为300元，总计额为932元
在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为: 5,50,200,800,80,700
最高奖项为800元，总计额为1835元
在此次抽奖过程中,抽奖箱2中产生了最大奖项，该奖项金额为800元
分析：最大奖项应该这两个线程结束后再比较，采用有返回值的线程创建方法，将最大值返回后打印。

public class MyCallable implements Callable<Integer> {
    ArrayList<Integer> list;//静态变量

    //可以利用构造方法
    public MyCallable(ArrayList<Integer> list) {
        this.list = list;
    }

    @Override
    public Integer call() throws Exception {
        ArrayList<Integer> List=new ArrayList<>();
        while (true) {
            synchronized (MyCallable.class) {
                if (list.size() == 0) {
                    System.out.println(Thread.currentThread().getName()+List);
                    break;
                } else {
                    Collections.shuffle(list);//打乱list数据
                    int prize = list.remove(0);
                    List.add(prize);
                }
            }
                Thread.sleep(100);//目的是可以让两个线程交替进行显示
        }
        //把集合中的最大值返回
        if(List.size()==0){
            return null;
        }else{
           return Collections.max(List);
        }

    }
}

public class test1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);
        MyCallable mc=new MyCallable(list);
        FutureTask<Integer> ft1=new FutureTask<>(mc);
        FutureTask<Integer> ft2=new FutureTask<>(mc);
        Thread t1=new Thread(ft1);
        Thread t2=new Thread(ft2);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
        int max1=ft1.get();
        int max2=ft2.get();
        System.out.println(max1);
        System.out.println(max2);
    }
    }

线程池

核心原理：

创建线程池

创建一个没有上限的线程池：

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=1;i<=100;i++){
            System.out.println(Thread.currentThread().getName()+"--"+i);
        }
    }
}
public class test1 {
    public static void main(String[] args)  {
        //创建线程池对象
      ExecutorService poll= Executors.newCachedThreadPool();
      //提交任务
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        //线程池一般不会关闭
    }
    }

创建一个有上限的线程池：

public class test1 {
    public static void main(String[] args)  {
        //创建线程池对象
      ExecutorService poll= Executors.newFixedThreadPool(2);
      //提交任务
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        poll.submit(new MyRunnable());
        //线程池一般不会关闭
    }
    }

自定义线程池

系统先会创建服务于任务1、2、3的线程1、2、3；再将任务4、5、6拿去排队；再调用临时线程服务于任务7、8、9；任务10会触发任务拒绝策略。

任务拒绝策略

创建自定义线程池：

public class test1 {
    public static void main(String[] args)  {
        //自定义线程池
        ThreadPoolExecutor pool=new ThreadPoolExecutor(
                3,//核心线程的数量
                6,//最大线程数
                60,//空闲线程最大存活时间
                TimeUnit.SECONDS,//时间单位
                new ArrayBlockingQueue<>(3),//任务队列，相当于阻塞队列
                Executors.defaultThreadFactory(),//创建线程工厂:线程池如何获取到一个线程
                new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
        );
    }
    }