Java多线程

Java多线程 Learn

Learn from kuangshen

概述

JavaThread 类

多任务：吃饭玩手机

1、Theard 进程：系统中运行的程序，比如：QQ, 播放器，游戏等，一个进程包含多个线程 Process。

2、线程，是独立的执行路径，如main()函数。

线程创建

线程开启后，不一定立刻执行，由CPU调度。

//创建线程。run()是线程体， 执行testThread1.start();开启
//testThread1.run();会执行完run(),再进入下一句
public class TestThread extends Thread{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {
        //main线程
        TestThread testThread1 = new TestThread();
        testThread1.start(); //开启线程，run()函数开始，但main会同时进入下一步

        for (int i = 0; i < 10; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

多线程下载图片

可能遇到证书问题，参考解决方法

还需要关闭系统网络代理

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class TestThread extends Thread{

    private String url; //图片下载路径
    private String filename; //图片保存名称

    public TestThread(String url, String filename) {
        this.url = url;
        this.filename = filename;
    }

    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        try {
            webDownloader.downloader(url,filename);
            System.out.println("下载文件名为："+filename);
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("下载失败！。。");
        }
    }


    public static void main(String[] args) {
        TestThread t1 = new TestThread("https://www.kuangstudy.com/assert/images/indexlogo.png","1.jpg");
        TestThread t2 = new TestThread("https://www.kuangstudy.com/assert/images/indexlogo.png","2.jpg");
        TestThread t3 = new TestThread("https://www.kuangstudy.com/assert/images/indexlogo.png","3.jpg");
        t1.start();
        t2.start();
        t3.start();

    }
}

class WebDownloader{
    //下载方法
    public void downloader(String url,String filename)throws Exception{
        try {
            FileUtils.copyURLToFile(new URL(url),new File(filename));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现异常！");
        }
    }
}

Runable接口

public class Thread3 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我在看代码"+i);
        }
    }

    public static void main(String[] args) {

        //创建runable接口的现实对象
        Thread3 thread3 = new Thread3();

        //创建线程对象，通过线程对象来开启线程，代理Thread
//        Thread thread = new Thread(thread3);
//        thread.start();
        new Thread(thread3).start();

        for (int i = 0; i < 10; i++) {
            System.out.println("我在学习多线程"+i);
        }
    }
}

并发问题

存在多个线程操作同一个资源情况下，线程不安全，数据紊乱。

public class Thread4 implements Runnable{
    //票数
    private int ticketNums=10;

    @Override
    public void run() {
        while(true)
        {
            if (ticketNums<=0){break;}
            System.out.println(Thread.currentThread().getName()+ "-->拿到了第 "+ticketNums--+" 张票");        }
    }

    public static void main(String[] args) {
        Thread4 ticket = new Thread4();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"黄牛党").start();
    }
}

龟兔赛跑

两个线程比喻为兔子和乌龟，其中线程暂停比喻为兔子休息。

public class Race implements Runnable{

    private static String winner;
    @Override
    public void run() {
        for (int i = 1; i < 300; i++) {
            if(Thread.currentThread().getName().equals("rabbit") && i%11==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            boolean flag = gameOver(i);
            if (!flag) {
                System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步！");
            }
            else{
                break;
            }
        }
    }

    //判断比赛是否完成
    private boolean gameOver(int steps){
        if(winner!=null){
            return true;
        }else if(steps>=20){
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner + " !");
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        Race race = new Race();
        new Thread(race,"rabbit").start();
        new Thread(race,"tortoise").start();
    }
}

Callable

线程池：1、创建执行服务；2、提交执行；3、获取结果；4、关闭服务

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qBhfGRr-1624501338475)(https://i.loli.net/2021/06/22/uglp8I72qRtzSnf.png)]

静待代理

真实对象与代理对象都要实现同一个接口interface

代理对象要代理真实对象，必须调用真实对象。

好处：代理对象可以做很多真实对象做不了的事情。真实对象只做自己的事情。

public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();//创建真实对象
        MarryCompany marryCompany = new MarryCompany(you);
        marryCompany.HappyMarry();
    }
}

interface Marry{
    void HappyMarry();
}

//真实对象
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println(" Marry ing!");
    }
}


//代理对象
class MarryCompany implements Marry{
    private Marry target;
    public MarryCompany(Marry target){//传递一个真实角色
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        System.out.println("结婚之前，布置场景！");
        this.target.HappyMarry(); //调用真实对象
        System.out.println("结婚之后，收尾款!");
    }
}

Lamdba表达式

使用原因：避免内部类定义过多，使代码简洁。

函数式接口：只包含唯一一个抽象方法的接口。Runable是一个例子。

lambda使用于函数式接口。

public class TestLamdba1 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lamdba() {
            System.out.println("learn Lambda!");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lamdba();  //I Like Lambda!

        like = new Like2();
        like.lamdba();  //learn Lambda!

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void lamdba() {
                System.out.println("learn Lambda333!");
            }
        }
        like = new Like3();
        like.lamdba();  //learn Lambda333!

        //5.匿名内部类。没有类的名称，必须借助接口或父类
        like = new ILike() {
            @Override
            public void lamdba() {
                System.out.println("learn Lambda 55");
            }
        };
        like.lamdba();  //learn Lambda 55

        //6.用lambda简化
        like = ()-> {
            System.out.println("learn Lambda 66");
        };
        //调用interface中的方法，方法内容是上一行{}内的代码
        // learn Lambda 66
        like.lamdba();
    }
}

//1.定义一个函数式接口，只有一个抽象方法的接口
interface ILike{
    void lamdba();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lamdba() {
        System.out.println("I Like Lambda!");
    }
} 

//简化
public class TestLambda2 {
    public static void main(String[] args) {
        //1.lambda表示简化
        Alike like = (int a)->{
            System.out.println("learn lambda "+a);
        };

        //简化1.参数类型
        like =(a)->{
            System.out.println("learn lambda simple1"+a);
        };
        //简化2.去掉大括号,因为只有一行代码
        like = (a)-> System.out.println("learn lambda simple2");
        like.like(52);
    }
}

interface Alike{
    void like(int a);
}

线程五大状态

//1、创建；
Thread t = new Thread();
    
//2、就绪；
start();//线程进入就绪，但不意味着CPU立刻调度执行

//3、运行；
//CPU运行线程中的代码

//4、阻塞；
sleep();wait();等。线程中的代码不继续执行时

//5、死亡；
//线程中断或者结束，一旦进入死亡，不能再次启动

线程方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LqECc66j-1624501338477)(https://i.loli.net/2021/06/22/1tirD8YGnZoPRe4.png)]

线程停止

使用一个标志位进行终止变量，当flag=false,则终止线程运行。

利用次数，不建议死循环。

不使用stop()和destory()等JDK不推荐的方法。

public class TestStop implements Runnable{
    private boolean flag = true;

    @Override
    public void run() {
        int i=0;
        while(flag){
            System.out.println("Running....Thread"+i++);
        }
    }

    //创建一个stop()
    public  void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 20; i++) {
            System.out.println("running main thread"+i);
            if (i==15){
                testStop.stop();
                System.out.println("线程停止。。。");
            }
        }
    }
}

线程休眠

sleep();

1、模拟网络延时，提高线程安全性

public class TestSleep implements Runnable{
    //票数
    private int ticketNums=10;

    @Override
    public void run() {
        while (ticketNums > 0) {
            try {
                //模拟网络延时，提高线程安全性
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "-->拿到了第 " + ticketNums-- + " 张票");
        }
    }

    public static void main(String[] args) {
        Thread4 ticket = new Thread4();

        new Thread(ticket,"小明").start();
        new Thread(ticket,"小红").start();
        new Thread(ticket,"黄牛党").start();
    }
}

import java.text.SimpleDateFormat;
import java.util.Date;

//模拟倒计时
public class TestSleep2 implements Runnable{
    public void tenDown(){
        int num = 10;
        Date startTime = new Date(System.currentTimeMillis());

        do {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(num--);
        } while (num >= 0);
    }

    public static void main(String[] args) {
        TestSleep2 testSleep2 = new TestSleep2();

        new Thread(testSleep2).start();
    }

    @Override
    public void run() {
        tenDown();
    }
}

线程礼让

Thread.yield();

//测试礼让，不一定成功，看CPU调度
public class TestYield implements Runnable{
    @Override
    public void run() {

        System.out.println("线程开始 "+Thread.currentThread().getName());
        Thread.yield();
        System.out.println("线程终止 "+Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        TestYield testYield = new TestYield();

        new Thread(testYield,"a").start();
        new Thread(testYield,"b").start();
    }
}

Join合并线程

thread.join();

其它线程先让插队线程执行完，再执行。

//插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程VIP："+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        for (int i = 0; i < 100; i++) {
            if (i==20){
                thread.join();
            }
            System.out.println("main thread :"+i);
        }
    }
}

线程状态观测

Thread.getState();

public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state); //NEW

        //观察启动后
        thread.start();
        state = thread.getState();
        System.out.println(state); //RUNABLE

        while(state != Thread.State.TERMINATED){ //只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState(); //更新线程状态
            System.out.println(state); //TIMED_WAITING 或 RUNABLE
        }
    }
}

线程优先级

大多数情况下，优先级高的先跑。

Thread.NORM_PRIORITY=5
Thread.MIN_PRIORITY=1
Thread.MAX_PRIORITY=10

public class TestPriority
{
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority, "t1");
        Thread t2 = new Thread(myPriority, "t2");
        Thread t3 = new Thread(myPriority, "t3");
        Thread t4 = new Thread(myPriority, "t4");

        //先设置优先级再启动
        t1.start();
        
        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(8);
        t4.start();
    }
}
class MyPriority implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}

线程守护

应用于：后台记录操作日志，监控内存，垃圾回收等。

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        Persons persons = new Persons();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认false表示用户线程，一般的线程都是用户线程

        thread.start();
        System.out.println(thread.getState()+" 是守护线程状态");
        Thread person1 = new Thread(persons);
        person1.start();//用户线程启动，
        System.out.println(person1.getState()+" 是被守护线程状态");
    }
}


//God
class God implements Runnable{
    @Override
    public void run() {
        while(true) {
            System.out.println("上帝保佑！");
        }
    }
}

//Persons
class Persons implements  Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            System.out.println("每天开心的活着！");
        }
    }
}

线程同步

并发：对各线程访问同一个对象。

线程同步其实是一种等待机制，多个线程在对象等待池形成队列，等前面一个线程使用完毕，下一个线程再使用。

队列+锁

//抢票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"小明").start();
        new Thread(station,"小红").start();
        new Thread(station,"小白").start();

    }
}

class BuyTicket implements Runnable{
    private int ticketNums = 10;
    boolean flag = true;
    @Override
    public void run() {
        while(flag) {
            buy();
        }
    }
//synchronized 方法同步，锁的是this
    private synchronized void buy(){
        if(ticketNums<=0){
            flag=false;
        }
        else{
            System.out.println(Thread.currentThread().getName()+
                    " 买到票！"+ticketNums--);
        }
    }
}

同步块

锁住增，删，改的操作！！Obj

synchronized(Obj){

}

package syn;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000, "基金");

        Drawing t1 = new Drawing(account,50,"小明");
        Drawing t2 = new Drawing(account,100,"小红");

        t1.start();
        t2.start();
    }
}


//账户
class Account{
    int money;
    String name;

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}


//银行
class Drawing extends Thread{
    Account account;
    int drawingMoney;
    int nowMoney;

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account = account;
        this.drawingMoney= drawingMoney;
    }

    @Override
    public void run() {
        synchronized(account){
            //判断有没有钱
            if(account.money-drawingMoney<0){
                System.out.println(Thread.currentThread().getName()+"想取钱，但是余额不足");
                return;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡余额 = 余额-取款
            account.money = account.money-drawingMoney;
            nowMoney = nowMoney+drawingMoney;

            System.out.print(this.getName()+"取了"+drawingMoney);
            System.out.println(account.name+  "  账户余额："+account.money+"！");
            //this.getName()=Thread.currentThread().getName() 是继承了Thread，所以有这个方法。
        }
    }
}

JUC

测试CopyOnWriteArrayList

//测试 JUC 安全类型的集合
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

死锁

例子：两个人化妆，口红和镜子是两个事件。g1调用口红延迟2秒再去调用镜子，期间g2已经调用镜子，g1会等待g2调用完，但是g2正在等g1的口红。于是陷入死锁。

产生死锁的条件：

1、互斥条件，一个资源只能被一个进程使用

2、请求与保持条件，一个进程因请求资源而阻塞时，对以获得的资源保持不放。

3、不剥夺条件，进程以获得的资源，在未使用完之前，不能强行剥夺。

4、循环等待条件，若干进程之间形成一种头尾相接的循环等待资源关系。

//死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1,"白雪公主");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick{

}

//镜子
class Mirror{

}

class Makeup extends Thread{
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    int choice;//选择
    String name;//选择化妆品的人

    public Makeup(int choice, String name) {
        this.choice = choice;
        this.name = name;
    }

    @Override
    public void run() {
        //方法：化妆
        makeup();
    }

    //化妆，互相持有对方的锁，就是对方的资源
    private void makeup(){
        if(choice==0){
            synchronized (lipstick){
                System.out.println(this.name+"获得口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (mirror){//1秒后获得镜子
                    System.out.println(this.name+"获得镜子的锁");
                }
            }
        }else{
            synchronized (mirror){
                System.out.println(this.name+"获得镜子的锁");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lipstick){
                    System.out.println(this.name+"获得口红的锁");
                }
            }
        }
    }
}

Lock锁

使用try finally加锁和解锁。

Lock只有代码块锁，Synchronized有代码块锁和方法锁。

//测试Lock锁
public class TestLock {
    public static void main(String[] args) {
        TestLock2 testLock2 = new TestLock2();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
class TestLock2 implements Runnable{
    int ticketNums=10;
    //   定义lock
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                lock.lock();
                if (ticketNums>0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                }
                else{
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

生产者模式

1、管程法：生产者-----数据缓冲区-----消费者

2、信号灯法，用flag协调

//测试：生产消费者模型。--->利用缓冲区解决：管程法

//生产者，消费者，产品。
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();

        new Productor(container).start();
        new Consumer(container).start();
    }
}

//生产者
class Productor extends Thread{
    SynContainer container;

    public Productor(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("生产了第"+i+"只鸡！");
            container.push(new Chicken(i));
        }
    }
}

//消费者
class Consumer extends Thread{
    SynContainer container;

    public Consumer(SynContainer container) {
        this.container = container;
    }
    @Override
    public void run() {
        for (int i = 0; i < 30; i++) {
            System.out.println("消费了第"+container.pop().id+"只鸡！");
        }
    }
}

//产品
class Chicken{
    int id; //产品编号
    public Chicken(int id) {
        this.id = id;
    }
}

//缓冲区
class SynContainer{
    //需要一个容器大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就要停止，等待消费着消费
        if(count==chickens.length){
            //通知消费者，同时生产停止
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，就push产品
        chickens[count] = chicken;
        count++;
        this.notifyAll();//通知消费着消费
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        //判断能否消费
        if(count==0){
            //等待生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();//吃了，通知生产者生产
        return chicken;
    }
}

信号灯法测试。

public class TestPC2 {
    public static void main(String[] args) {
        TV tv =new TV();

        new Player(tv).start();
        new Watcher(tv).start();

    }
}


//生产者--演员
class Player extends Thread{
    TV tv;

    public Player(TV tv) {
        this.tv = tv;
    }
    @Override
    public void run(){
        for (int i = 0; i < 20; i++) {
            if(i%2==0){
                this.tv.play("小猪佩奇播放中！");
            }
            else{
                this.tv.play("奥特曼播放中！");
            }
        }
    }
}
//消费者--观众
class Watcher extends Thread{
    TV tv;

    public Watcher(TV tv) {
        this.tv = tv;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}
//产品--节目
class TV{
    String voice;
    boolean flag = true;

    //表演
    public synchronized void play(String voice){
       if(!flag){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
        }
        System.out.println("演员表演了"+voice);
        this.notifyAll();//通知观众
        this.voice = voice;
        this.flag = !flag;
    }

    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了："+voice);
        this.notifyAll();//通知演员
        this.flag = !flag;
    }
}

线程池

背景：经常创建和销毁、使用特别大的资源，比如并发情况下的线程，对性能影响特别大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建和销毁，实现重复利用。类似生活中的交通工具。

好处：

1、提高响应速度，减少了创建新线程的时间

2、降低资源消耗，重复利用线程池中线程，不需要每次创建

3、便于线程管理。(a) corePoolSize 线程池的大小；(b) maximumPoolSize 最大线程数；© KeepAliveTime 线程没有任务时最多保持多长时间后会终止。

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

public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool 参数为：线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭链接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

= !flag;
}
}

## 线程池

背景：经常创建和销毁、使用特别大的资源，比如并发情况下的线程，对性能影响特别大。

思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建和销毁，实现重复利用。类似生活中的交通工具。

好处：

1、提高响应速度，减少了创建新线程的时间

2、降低资源消耗，重复利用线程池中线程，不需要每次创建

3、便于线程管理。(a) corePoolSize 线程池的大小；(b) maximumPoolSize 最大线程数；(c) KeepAliveTime 线程没有任务时最多保持多长时间后会终止。

 ```java
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
 public class TestPool {
     public static void main(String[] args) {
         //1.创建服务，创建线程池
         //newFixedThreadPool 参数为：线程池大小
         ExecutorService service = Executors.newFixedThreadPool(10);
 
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
         service.execute(new MyThread());
 
         //2.关闭链接
         service.shutdown();
     }
 }
 
 class MyThread implements Runnable{
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName());
     }
 }