Java并发与多线程

开篇声明:此博客是我的学习笔记,有一些理论知识和例子说明,写的内容不是特别深,大家可以用来参考,有问题可以评论,随着学习的深入,后续还有内容会更新,想要看的可以收藏一下

并发与多线程

在此之前,我们所学到的都是有关顺序编程的知识,即程序中的所有事物在任意时刻都只能执行一个步骤.

什么是线程?

进程可以进一步细化为线程,是一个程序内部的一条执行路径

单核CPU和多核CPU?

• 单核CPU
  是一种假的多线程,在一个时间单元内,只能执行一个线程任务

• 多核CPU
  多核CPU才能更好的发挥多线程的效率(现在大多CPU都是多核的)

• 一个Java应用程序,至少有三个线程:main()主线程,gc()垃圾回收线程,异常处理线程.当然发生异常会影响主线程

并行与并发?

• 并行:多个CPU同时执行多个任务
• 并发:一个CPU(采用时间片)同时执行多个任务.比如:秒杀,多个人做同一件事

多线程的优点?

背景:单核CPU为例,只是用单个线程先后完成多个任务(调用多个方法),肯定比用多个线程来完成用的时间短,但为何仍需多线程

优点:

• 提高应用程序响应.对图形界面更有意义,可增强用户体验
• 提高计算机系统CPU的利用率
• 改善程序结构.将即长又复杂的进程分为多个线程,独立运行,利于理解和修改

何时需要使用多线程?

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

---

线程的创建和使用

线程的创建和启动

• Java语言的JVM允许程序运行多个线程,他通过java.lang.Thread类来提现

• Thread类的特性

  • 每个线程都是通过某个特定的Thread对象的run方法来完成操作的,经常把run方法的主体称为线程体
  • 通过该Thread对象的start()方法来启动这个线程,而非直接调用run()

多线程创建(方法1)

• 方法1:
  • 创建一个继承于Thread类的子类
  • 重写Thread类的run()–>将此线程执行的操作声明在run()中
  • 创建Thread类的子类的对象
  • 通过此对象调用start()
    • 启动当前线程
    • 调用当前线程的run()方法

**例子:**遍历100以内的所有偶数

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-15
 * Time: 10:20
 */

//1.创建一个继承与Thread类的子类
class MyThread extends Thread{
    //2.重写Thread子类的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) {
        MyThread thread = new MyThread(); //3.创建Thread类的子类的对象
        thread.start(); //4.通过此对象调用start()
		
		//主线程中操作
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i + "*******main()*******");
            }
        }
    }
}

练习:

package com.codeqs.exer;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-15
 * Time: 11:11
 */

/**
 * 练习:创建两个线程,一个遍历100以内的偶数,一个遍历100以内的奇数
 */
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 thread1 = new MyThread1();
        MyThread2 thread2 = new MyThread2();
        thread1.start();
        thread2.start();
    }
}

多线程Thread类的常用方法

• void start():启动线程,并执行对象的run()方法
• run():线程在被调度时执行的操作
• String getName():返回线程的名称
• void setName(String name):设置该线程名称
• static Thread currentThread():返回当前线程.在Thread子类种就是this,通常用于主线程和Runnable实现类
• yield():释放当前CPU的执行权
• join(): 在线程a中调用线程b的join(),此时线程a就进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞状态
• stop:(已过时,不推荐使用)
• sleep(long millitime):让当前线程"睡眠"指定的millitime毫秒,在指定的millitime毫秒内当前线程是阻塞状态.
• isAlive():判断当前线程是否存活

线程的调度

调度策略

• 时间片
• 抢占式:高优先级的线程抢占CPU

调度方法

• 同优先级线程组成先进先出队列(先到先得服务),使用时间片策略
• 对高优先级,使用优先调度的抢占式策略

线程优先级等级

• MAX_PRIORITY:10
• MIN_PRIORITY:1
• NORM_PRIORITY:5
• 说明:最高的优先级有较高概率先执行,并不是绝对先执行完高优先级,再执行低优先级

涉及的方法

• getPriority():返回线程优先值
• setPriority(int newPriority):改变线程优先级

代码演示

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-15
 * Time: 10:20
 */

//1.创建一个继承与Thread类的子类
class MyThread extends Thread{
    //2.重写Thread子类的run方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+getPriority()+":"+i);
            }
        }
    }
}

public class ThreadTest {
    public static void main(String[] args) {
        MyThread thread = new MyThread(); //3.创建Thread类的子类的对象
        thread.setPriority(Thread.MAX_PRIORITY);//给分线程设置最高优先级
        thread.setName("分线程");
        thread.start(); //4.通过此对象调用start()

        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);//给主线程设置最低优先级
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority()+":"+i + "*******main()*******");
            }
        }
    }
}

练习

创建三个窗口买票,总票数为100张(仍存在线程安全问题)

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-15
 * Time: 22:46
 */
class Window extends Thread{

    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            if(ticket > 0) {
                System.out.println(getName()+":售票,票号为:"+ticket);
                --ticket;
            }else{
                break;
            }
        }
    }
}
public class WindowsTest {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

多线程创建(方法2)

方法二:实现Runnable接口

• 1.创建一个实现了Runnable接口的类
• 2.实现类去实现Runnable中的抽象方法:run()
• 3.创建实现类的对象
• 4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
• 5.通过Thread类的对象调用start

例子:(两个线程遍历100以内的偶数)

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 9:12
 */

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

public class ThreadTest1{
    public static void main(String[] args) {
        MyThread1 mythread = new MyThread1(); //3.创建实现类的对象
        Thread thread1 = new Thread(mythread); //4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
        thread1.setName("线程1");
        thread1.start(); //5.通过Thread类的对象调用start
        
        Thread thread2 = new Thread(mythread);
        thread2.setName("线程2");
        thread2.start();
    }
}

练习(创建三个窗口买票,总票数为100张(仍然存在线程安全问题))

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 9:44
 */

class MyWindows implements Runnable{

    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}

public class WindowsTest1 {
    public static void main(String[] args) {
        MyWindows window = new MyWindows();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

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

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

比较创建线程的两种方式:

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

原因:

• 1.实现的方式没有类的单继承性的局限性
• 2.实现的方式更适合来处理多个线程有共享数据的情况

联系:public class Thread implements Runnable

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

---

线程的生命周期

一个完整的生命周期通常包含以下五类:

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

---

线程的安全问题

举例说明(解决买票问题的线程安全问题):

1.问题:买票过程中,出现了重票,错票–>出现了线程的安全问题

2.问题出现的原因:当某个线程操作车票的过程中,尚未完成时,其他线程参与进来,也操作车票

3.如何解决:当一个线程a在操作共享数据(车票ticket)的时候,其他线程不能参与进来,知道线程a操作完ticket时,其他线程才可以开始操作ticket.这种情况即使线程a出现了阻塞,也不能被改变.

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

方式一:同步代码块

• synchronized(同步监视器){//需要被同步的代码}
• 说明:
  • 1.操作共享数据的代码,即为需要被同步的代码
  • 2.共享数据:多个线程共同操作的变量,比如:下例中的ticket就是共享数据
  • 3.同步监视器,俗称:锁.任何一个类的对象,都可以充当锁
    • 要求:多个线程必须要共用同一把锁

例子1(实现Runnable):

实现Runnable时,同步监视器可以考虑this充当

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 10:41
 */
class MyWindows1 implements Runnable{

    private static int ticket = 100;
    @Override
    public void run() {
        while (true){
            synchronized(this) {//this代表当前对象
                if (ticket > 0) {

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

                    System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowsTest2 {
    public static void main(String[] args) {
        MyWindows1 window = new MyWindows1();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

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

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

例子2(继承Thread)

继承Thread时,同步监视器可以考虑用当前类.class充当

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-15
 * Time: 22:46
 */
class MyWindow2 extends Thread{

    private static int ticket = 100;
    /**
     * 多个线程必须使用用一个锁,main方法中new了MyWindow2类的三个实例
     * 如果不声明为static就会new一个实例声明一个obj,线程安全就不会被实现
     * */
    private static Object obj = new Object();

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

            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + ":售票,票号为:" + ticket);
                    --ticket;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowsTest3 {
    public static void main(String[] args) {
        MyWindow2 w1 = new MyWindow2();
        MyWindow2 w2 = new MyWindow2();
        MyWindow2 w3 = new MyWindow2();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

方式二:同步方法

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

• 1.同步方法仍然涉及到同步监视器,知识不需要我们现实的声明
• 2.1.非静态的同步方法,同步监视器是:this
• 2.2.静态的同步方法,同步监视器是:当前类本身

例子1(实现Runnable):

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 21:06
 */
class MyWindow3 implements Runnable{

    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            show();
            if(ticket == 0) break;
        }
    }
    private synchronized void show(){
        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
            ticket--;
        }
    }
}
public class WindowsTest4{
    public static void main(String[] args) {
        MyWindow3 window = new MyWindow3();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);

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

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

例子2(继承Thread)

package com.codeqs.java;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 21:26
 */
class MyWindow4 extends Thread{


    private static int ticket = 100;

    @Override
    public void run() {
        while (true){
            show();
            if(ticket == 0){
                break;
            }
        }
    }
    private static synchronized void show(){//同步监视器是MyWindows4.class
        if(ticket > 0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
            ticket--;
        }
    }

}
public class WindowsTest5 {
    public static void main(String[] args) {
        MyWindow4 w1 = new MyWindow4();
        MyWindow4 w2 = new MyWindow4();
        MyWindow4 w3 = new MyWindow4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

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

---

线程安全的单例模式之懒汉式

代码演示

package com.codeqs.java1;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 21:58
 */
public class BankTest {
}
class Bank{
    private Bank(){}
    private static Bank instance = null;
    private synchronized static Bank getInstance(){ //这里也可以使用同步代码块
        if(instance == null){
            instance = new Bank();
        }
        return instance;
    }
}

---

####死锁

• 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
• 出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续

解决办法

• 专门的算法,原则
• 尽量减少同步资源的定义
• 尽量避免嵌套同步

代码演示

package com.codeqs.java1;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-17
 * Time: 22:40
 */
public class ThreadTest {
    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();

    }
}

Lock(锁) — JDK5.0版本及以上

• 从JDK5.0开始,Java提供了更强大的线程同步机制–通过显示定义同步锁对象来实现同步.同步锁使用Lock对象充当
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具.锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
• ReentrantLock类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显示的加锁,释放锁.

用法

• 1.实例化ReentrantLock
• 2.将需要锁的部分用try包起来
• 3.调用锁定lock方法
• 4.调用解锁方法unlock

代码演示

package com.codeqs.java1;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-18
 * Time: 9:16
 */

class LockWindow implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock(true);//参数代表是否公平分配
    @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) {
        LockWindow w = new LockWindow();
        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();
    }
}

面试题:synchronized 与 Lock的异同

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

建议优先使用顺序:

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

#####面试题:如何解决线程安全问题?有几种方式

线程的通信

这里涉及三个线程通信的三个方法

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

说明

• 1.上面三个方法只能够出现在同步代码块或者同步方法中(lock中不可以,lock用其他方式)
• 2.上面三个方法的调用者,必须是同步代码块或同步方法中的同步监视器,否则会出现IllegalAccessException异常
• 3.上面三个方法是定义在java.lang.Object类中.

例子(使用两个线程打印1-100,线程1,线程2交替打印):

package com.codeqs.java1;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Administrator
 * Date: 2020-05-18
 * Time: 22:10
 */

class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {
        while(true){
            synchronized (this){
                notify(); //这里notify和notifyAll()都一样,没有什么区别,为了唤醒堵塞的线程,进入线程2唤醒线程1
                if(number <= 100){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用wait()方法的线程进入阻塞状态
                        //wait()会释放锁
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

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

---

2020年5月21日更新(新增Callable和线程池内容)

第三种线程创建方式(实现Callable接口)

• 与使用Runnable相比,Callable功能更强大些

  • 相比run()方法,可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助FutureTask类,比如获取返回结果

• Future接口

  • 可以对具体Runnable,Callable任务的执行结果进行取消,查询是否完成,获取结果等
  • FutureTask是Future接口唯一的实现类
  • FutureTask同时实现的Runnable,Future接口,它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值

基本实现过程

package com.codeqs.java1;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 行者-
 * Date: 2020-05-21
 * Time: 8:54
 */

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

/**
 * 线程创建的方式三:实现Callable接口.
 *
 * 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
 * 1.call()可以有返回值
 * 2.call()可以抛出异常,被外面操作捕获,获取异常信息
 * 3.Callable是支持泛型的
 */
//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 CallableTest {
    public static void main(String[] args) {
        //3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);

        //这里Thread内传入的参数为Runnable类型,FutureTask类实现了Runnable接口
        //启动线程
        //5.将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start方法
        new Thread(futureTask).start();

        try {
            //6.get()返回值即为FutureTask构造器参数Callable实现类的call()的返回值,不需要的话可以不使用
            Object sum = futureTask.get();
            System.out.println("总和为:"+sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

---

线程池

思路

提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中.可以避免频繁创建销毁,实现重复利用

好处

• 提高响应速度(减少了创建新线程的时间)
• 降低资源消耗(重复利用线程池中的线程,不需要每次都创建)
• 便于线程管理
  • corePollSize:核心池大小
  • maximumPollSize:最大线程数
  • keepAliveTime:线程没有任务时最多保持多长时间后会终止

线程池的使用

• ExecutorService:真正的线程池接口.常见子类ThreadPollExecutor

  • void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
  • Future submit(Callable task):执行任务,有返回值,一般用来执行Callable
  • void shutdown():关闭线程池

• Executors:工具类,线程池工厂类,用于创建并返回不同类型的线程池

  • Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池
  • Executors.newFixedThreadPool(n):创建一个可重用固定线程数的线程池
  • Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池
  • Executors.newScheduledThreadPool(n):创建一个线程池,它可安排在给定延迟后运行命令或者定期地执行

代码演示

package com.codeqs.java1;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 行者-
 * Date: 2020-05-21
 * Time: 9:52
 */

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

/**
 *  创建线程池的方式四:使用线程池
 */
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实现了ExecutorService 接口
        //这里为了完成下面对线程池属性的设置
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;	

        //设置线程池的属性
//        System.out.println(service.getClass());
        service1.setCorePoolSize(5);

        //2.执行指定的线程操作.需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
        service.execute(new NumberThread1());//适用于Runnable
//        service.submit(Callable callable);//适用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}

完结撒花

Java并发基础部分基本结束,并发容器/原子类/JUC并发工具类这几个还没有学习,后期学习到了我考虑看是在开一篇博文还是继续在这篇添加内容,谢谢大家观看(关注),再见

预告

下一篇写一下一些Java常用类的使用,下面有链接
https://blog.csdn.net/qqshuai9822/article/details/106252242