signed

QiShunwang

“诚信为本、客户至上”

Java基础--多线程

2021/1/28 13:51:09   来源:

多线程

一,程序、进程、线程

1.程序:

概念:是为了完成一特定任务,用某种语言编写的一组指定的集合。指一套静态的代码。

2.进程

概念:程序的一次执行,也可以说是正在运行的程序。说明:进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域。

3.线程

概念:进程可进一步细化为线程,是一个程序内部的一条执行路径。说明:线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器,线程切换的开销小。

内存结构

每个线程都有自己独立的栈和程序计数器,多个线程共享同一个进程中的方法区和堆。

二、并行与并发

1.单核CPU与多核CPU

  • 单核:是一种假的多线程,在一个单元时间内,只能执行一个线程的任务。将其他线程设置为阻塞状态,等到处理完后就从就绪队列中取出新的线程进行处理,由于切换和处理时间快,用户感知不到。
  •  一个Java应用程序Java.exe,其实至少三个线程:main()主线程,gc()垃圾回收线程,异常处理线程。如果发生异常,会影响主线程。

2.并行与并发的理解

并行:是指多个cpu同时执行多个任务。比如:多个人同时做不同的事。

并发:一个cpu同时执行多个任务。 比如:秒杀,多个人同时做一件事。

为什么要使用多线程,多线程的优点:

  1. 提高应用程序的响应,可增强用户的体验。
  2. 提高计算机cpu的利用率
  3. 改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解。

应用的场景:

  1. 程序需要同时执行两个或多个任务
  2. 程序需要实现一些需要等待的任务时,如用户输入,文件读写操作、网络操作、搜索等
  3. 需要一些后台运行的程序时

三、Thread类

java语言的jvm允许程序运行多个线程,它通过java.lang.Thread类来体现

1,Thread类的特性

每个线程都是通过Thread对象的run方法来完成操作的,把run方法的主体称为线程体 通过该Thread对象的Start来启动这个线程,而不是直接调用run(),如果直接调用 就不能称为线程和普通的方法没有区别

2,构造器:

Thread():创建新的Thread对象

Thread(String threadName):创建线程并指定线程实例名

Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接口中的run方法

Thread(Runnable target,String name):创建了新的Thread对象

3.创建多线程的两种方式(重要)

3.1 方式一:继承于Thread类:

1,创建一个类继承与Thread类

2,重写Thread类的run()方法

3,创建该类的对象

4,通过此对象调用start():启动当前线程,调用run方法

注意点

  1. 启动一个线程,必须调用start()。如果再启动一个线程,必须重新创建一个Thread子类的对象。
  2. run()方法由jvm调用,什么时候调用,执行的过程控制都由操作系统的cpu调度决定。
  3. 想要启动多线程,必须调用start()方法。
  4. 一个线程只能调用一次start方法启动,如果重复调用了,则将抛出异常“lllegalThreadStateException"

代码示例:

//1.继承Thread类
class MyThread extends Thread {
    public MyThread() {
    }

    //2.重run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
//3.新建Thread对象
        MyThread myThread = new MyThread();
        //4.调用start方法
        myThread.start();
    }
}

3.2 方式二:实现Runable接口的方式:

1,创建一个类实现runable接口。

2,实现run()方法

3,创建此类的对象

4,将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象

5,通过Thread类的对象调用start()

//1. 创建一个实现了Runnable接口的类
public class RunnableTest implements Runnable {
    // 2. 实现类去实现Runnable中的抽象方法:run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

class test {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        RunnableTest runnableTest = new RunnableTest();
        //4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
        Thread thread = new Thread(runnableTest);
        //5. 通过Thread类的对象调用start()
        thread.start();

    }
}

两种方式的对比:

开发中优先选择:实现runnable接口的方式

原因:

1,实现的方式没类的单继承的局限性

2,实现的方式更适合来处理多个线程共享数据的情况。

也可以使用创建匿名类的方式:

new Thread().start();

4.Thread类常用的方法

  1. start():启动当前线程;调用当前线程的run(),只有Thread类和她的子类才能调用start()方法
  2. run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中。
  3. currentThread():静态方法,返回执行当前代码的线程
  4. getName():
  5. setName()
  6. yield():释放当前cpu的执行权
  7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b执行完后,线程a才结束阻塞状态。
  8. sleep(毫秒值):让当前线程睡眠。在指定的毫秒时间内,当前线程是阻塞状态
  9. isAlive():判断当前线程是否存活。

线程的优先级:

  • MAX_PRIORITY:10
  • MIN_PRIORITY:1
  • NORM_PRIORITY:5-->默认优先级

获取和设置当前线程的优先级:

getPriority():获取线程的优先级

setPriority(int p):设置线程的优先级

说明:高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲,高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后,低优先级的线程才执行。

线程通信:wait() / notify() / notifyAll() :此三个方法定义在Object类中的。

线程的分类

  • 守护线程,如:垃圾回收线程,依赖于主线程而存在
  • 用户线程,如:main方法的线程

5. Thread的生命周期

线程的五种状态:

  • 新建:当一个 Thread类或其子类的对象被声明并创建时,新生的线程对象处于新建状态
  • 就绪:处于新建状态的线程被star()后,将进入线程队列等待CPU时间片,此时它已具备了运行的条件,只是没分配到CPU资源
  • 运行:当就绪的线程被调度并获得CPU资源时,便进入运行状态,run()方法定义了线程的操作和功能
  • 阻塞:在某种特殊情况下,被人为挂起或执行输入输出操作时,让出CP∪并临时中止自己的执行,进入阻塞状态
  • 死亡:线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

说明:

  1. 生命周期关注两个概念:状态、相应的方法

  2. 关注:状态a-->状态b:哪些方法执行了(回调方法) 某个方法主动调用:状态a-->状态b

  3. 阻塞:临时状态,不可以作为最终状态

  4. 死亡:最终状态。

四、线程的同步机制

1.背景

例子:创建个窗口卖票,总票数为100张.使用实现Runnable接口的方式

  • 问题:卖票过程中,出现了重票、错票 -->出现了线程的安全问题
  • 问题出现的原因:当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。
  • 如何解决:当一个线程a在操作ticket的时候,其他线程不能参与进来。直到线程a操作完ticket时,其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞,也不能被改变。

2. Java解决方案:同步机制

在Java中,我们通过同步机制,来解决线程的安全问题。

2.1 方式一:同步代码块

synchronized(同步监视器){//同步监视器就是需要同步线程的公共对象
   //需要被同步的代码
    
}

说明:

  1. 操作共享数据的代码,即为需要被同步的代码。 -->不能包含代码多了,也不能包含代码少了。
  2. 共享数据:多个线程共同操作的变量。比如:ticket就是共享数据。
  3. 同步监视器,俗称:锁。任何一个类的对象,都可以充当锁。
  4. 要求多个线程必须要共用同一把锁。
  • 在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。

  • 在继承Thread类创建多线程的方式中,慎用this充当同步监视器,考虑使用当前类充当同步监视器。

代码示例:

继承Runnable接口形式同步代码块

public class Ticket implements Runnable {
    private int tick = 100;

    @Override
    public void run() {

        while (true) {
            synchronized (this) {
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "号窗口买票,票号为:" + tick--);
                } else {
                    break;
                }
            }
        }
    }
}

class TicketTest {
    public static void main(String[] args) {
        Ticket ticket = new Ticket();

        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}

继承Thread类形式同步代码块

public class Ticket2 extends Thread {
    private static int tick = 100;
    private static Object object = new Object();

    public Ticket2() {
    }

    @Override
    public void run() {

        while (true) {
            synchronized (object) {
            //synchronized (Ticket2.class) {//通过反射调用当前类
                if (tick > 0) {
                    System.out.println(Thread.currentThread().getName() + "号窗口买票,票号为" + tick--);
                } else {
                    break;
                }
            }

        }
    }
}

class TicketTest2 {
    public static void main(String[] args) {
        Ticket2 ticket1 = new Ticket2();
        Ticket2 ticket2 = new Ticket2();
        Ticket2 ticket3 = new Ticket2();

        ticket1.setName("窗口1");
        ticket2.setName("窗口2");
        ticket3.setName("窗口3");

        ticket1.start();
        ticket2.start();
        ticket3.start();


    }
}

2.2 方式二:同步方法

如果操作共享数据的代码完整的声明在一个方法中,我们不妨将此方法声明同步的。

public synchronized void show(String namer){
....
}

代码示例:

public class Ticket3 implements Runnable {
    private int tick = 100;
    private boolean isFlag = true;

    @Override
    public void run() {
        while (isFlag) {
            show();

        }
    }

    public synchronized void show() {//同步show方法,继承Thread类方法一样,只需同步方法即可,同时需要给方法加static关键字,确保不会创建多个对象
        if (tick > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "号窗口买票,票号为:" + tick--);
        } else {
            isFlag = false;
        }
    }
}

class TicketTest3 {
    public static void main(String[] args) {
        Ticket3 ticket = new Ticket3();

        Thread thread1 = new Thread(ticket);
        Thread thread2 = new Thread(ticket);
        Thread thread3 = new Thread(ticket);

        thread1.setName("窗口1");
        thread2.setName("窗口2");
        thread3.setName("窗口3");

        thread1.start();
        thread2.start();
        thread3.start();

    }
}

2.3 方式三:Lock锁 --- JDK 5.0新增

  • 从JDK 5.0开始,Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。
  • ReentrantLock类实现了Lock,它拥有与 synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是 Reentrantlock,可以显式加锁、释放锁。
class A {
    //1.实例化ReentrantLock对象
    private final ReenTrantLock lock = new ReenTrantLook();
    public void m (){
        lock.lock//2.先加锁
        try{
            //保证线程同步的代码
        }finally{
            lock.unlock();//3.后解锁
        }
    }
}

//注意:如果同步代码块有异常,要将unlock()写入finally语句块中

代码示例:

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法:unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

3.同步方法的总结:

在《 Thinking in Java》中,是这么说的:对于并发工作,你需要某种方式来防止两个任务访问相同的资源(其实就是共享资源竞争)。防止这种冲突的方法就是当资源被一个任务使用时,在其上加锁。第一个访问某项资源的任务必须锁定这项资源,使其他仼务在其被解锁之前,就无法访问它了,而在其被解锁之时,另一个任务就可以锁定并使用它了。

synchronized的锁是什么

  1. 任意对象都可以作为同步锁。所有对象都自动含有单一的锁(监视器)
  2. 同步方法的锁:静态方法(类名.class)、非静态方法(this)
  3. 同步代码块:自己指定,很多时候也是指定为this或类名.class

注意点:

  1. 必须确保使用同一个资源的多个线程共用一把锁,这个非常重要,否则就无法保证共享资源的安全
  2. 一个线程类中的所有静态方法共用同一把锁(类名.class),所有非静态方法共用同一把锁(this),同步代码块(指定需谨慎)
  3. 同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
  4. 非静态的同步方法,同步监视器是:this
  5. 静态的同步方法,同步监视器是:当前类本身

4. 同步的范围:

如何找问题,即代码是否存在线程安全?(非常重要

(1)明确哪些代码是多线程运行的代码

(2)明确多个线程是否有共享数据

(3)明确多线程运行代码中是否有多条语句操作共享数据

如何解决呢?(非常重要)

对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。 即所有操作共享数据的这些语句都要放在同步范围中

注意点:

范围太小:没锁住所有有安全问题的代码 范围太大:没发挥多线程的功能。

5. 面试题:

1. synchronized 与 Lock的异同?

  1. 相同:二者都可以解决线程安全问题

  2. 不同:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器

  3. Lock需要手动的启动同步(lock(),同时结束同步也需要手动的实现(unlock())

  4. 使用的优先顺序:

    Lock---> 同步代码块(已经进入了方法体,分配了相应资源 ) --->同步方法(在方法体之外)

  5. 利弊: 同步的方式,解决了线程的安全问题。---好处 操作同步代码时,只能一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。

2. Java是如何解决线程安全问题的,有几种方式?并对比几种方式的不同

利用同步锁的方式,有三种方式同步代码块、同步方法和用lock方法

3. synchronized和Lock方式解决线程安全问题的对比

  1. 相同:二者都可以解决线程安全问题
  2. 不同:synchronized机制在执行完相应的同步代码以后,自动的释放同步监视器
  3. Lock需要手动的启动同步(lock(),同时结束同步也需要手动的实现(unlock())

6. 线程安全的单例模式

使用同步机制将单例模式中的懒汉式改写为线程安全的。


class Bank{

    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
        //方式一:效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二:效率更高
        if(instance == null){

            synchronized (Bank.class) {
                if(instance == null){

                    instance = new Bank();
                }

            }
        }
        return instance;
    }

}

6. 死锁问题

  1. 死锁的理解: 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁

  2. 说明:

  • 出现死锁后,不会出现异常,不会出现提示,只是所的线程都处于阻塞状态,无法继续

  • 我们使用同步时,要避免出现死锁。

    死锁举例:

    public static void main(String[] args) {
    
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
    
    
        new Thread(){
            @Override
            public void run() {
    
                synchronized (s1){
    
                    s1.append("a");
                    s2.append("1");
    
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
    
                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");
    
                        System.out.println(s1);
                        System.out.println(s2);
                    }
    
    
                }
    
            }
        }.start();
    
    
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2){
    
                    s1.append("c");
                    s2.append("3");
    
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
    
                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");
    
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    
    
    }
    

五、线程通讯

为了解决线程的死锁问题,引入线程通讯

1. 线程通信涉及到的三个方法:

  • wait():一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器。
  • notify():一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级高的那个。
  • notifyAll():一旦执行此方法,就会唤醒所有被wait的线程。

2. 说明:

  • wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。

  • wait(),notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。

    否则,会出现IllegalMonitorStateException异常

  • wait(),notify(),notifyAll()三个方法是定义在java.lang.Object类中。

代码示例:

使用两个线程打印 1-100,线程1, 线程2 交替打印。

class MyThread implements Runnable {
    private int number = 1;
    private Object object = new Object();

    @Override
    public void run() {
        while (true) {

            synchronized (object) {
                object.notify();//调用notify()方法唤醒线程
                if (number <= 100) {
                    //线程休眠
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + number);
                    number++;

                    try {
                        object.wait();//打印输出一次后调用wait()方法将线程阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread thread1 = new Thread(myThread);
        Thread thread2 = new Thread(myThread);

        thread1.setName("线程1:");
        thread2.setName("线程2:");

        thread1.start();
        thread2.start();
    }
}

3. 面试题:

sleep() 和 wait()的异同?

相同点:一旦执行方法,都可以使得当前的线程进入阻塞状态。

不同点:

1)两个方法声明的位置不同:Thread类中声明sleep() , Object类中声明wait()

2)调用的要求不同:sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中

3)关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中,sleep()不会释放锁,wait()会释放锁。

4. 释放锁的操作:

  • 当前线程的同步方法、同步代码块执行结束
  • 当前线程在同步代码块、同步方法中遇到 break、 return终止了该代码块该方法的继续执行。
  • 当前线程在同步代码块、同步方法中出现了未处理的Error或 Exception,导致异常结束。
  • 当前线程在同步代码块、同步方法中执行了线程对象的 wait()方法,当前线程暂停,并释放锁

5. 不会释放锁的操作:

  • 线程执行同步代码块或同步方法时,程序调用 Thread. sleep()、Thread yield()方法暂停当前线程的执行
  • 线程执行同步代码块时,其他线程调用了该线程的 suspend()方法将该线程挂起,该线程不会释放锁(同步监视器)
  • 应尽量避免使用 suspend()和 resume()来控制线程

六、JDK 5.0新增线程创建方式

1. 新增方式一:实现Callable接口。

实现方法:

  1. 创建一个实现Callable的实现类

  2. 实现call方法,将此线程需要执行的操作声明在call()中

  3. 创建Callable接口实现类的对象

  4. 将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象

  5. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()

  6. 获取Callable中call方法的返回值

代码示例:

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法,将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        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();
        }
    }

}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?

  1. call()可以返回值的。
  2. call()可以抛出异常,被外面的操作捕获,获取异常的信息
  3. Callable是支持泛型的

2. 新增方式二:使用线程池

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

解决方案:

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

实现方法:

  1. 提供指定线程数量的线程池
  2. 执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
  3. 关闭连接池

相关API:

JDK 5.0起提供了线程池相关AP|: Executor Service和 Executors

Executor Service:真正的线程池接口。常见子类 Thread Poolexecutor
void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
<T> Future<T> submit(Callable<T>task):执行任务,有返回值,一般又来执行Callable
void shutdown():关闭连接池

Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
Executors. newCachedThreadPool():创建一个可根据需要创建新线程的线程池
Executors.newFⅸedthreadPool(n);创建一个可重用固定线程数的线程池
EXecutors. newSingleThreadEXecutor():创建一个只有一个线程的线程池
Executors. new thread Poo(n):创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行。

代码示例:

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable{

    @Override
    public void run() {
        for(int i = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(15);
//        service1.setKeepAliveTime();


        //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适合适用于Runnable
        service.execute(new NumberThread1());//适合适用于Runnable

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

应用线程池的好处:

  1. 提高响应速度(减少了创建新线程的时间)

  2. 降低资源消耗(重复利用线程池中线程,不需要每次都创建)

  3. 便于线程管理

    corePoolSize:核心池的大小

    maximumPoolSize:最大线程数

    keepAliveTime:线程没任务时最多保持多长时间后会终止

面试题:Java中多线程的创建有几种方式?四种。

JDK 5.0以前:

  • 即继承Thread类重run方法
  • 实现Runnable接口实现run方法

JDK 5.0以后:

  • 实现callable接口,实现call方法
  • 利用线程池