首页 > 其他分享 >4、多线程

4、多线程

时间：2023-10-20 17:47:44浏览次数：24  
标签：Thread money 线程 创建 new 多线程 public

多线程

一、线程的创建

1.1 线程的创建方式一：继承Thread类

Java为开发者提供了一种类叫做Thread，该类的对象用来表示线程。用此方法创建线程并执行的步骤如下：

  1. 定义一个子类继承Thread类，并重写run方法
  2. 创建该子类的实例对象
  3. 调用start方法启动线程（启动线程后，会自动执行run方法中的代码）

创建线程类的代码如下：

public class MyThread extends Thread{
    // 2、必须重写Thread类的run方法
    @Override
    public void run() {
        // 描述线程的执行任务。
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程MyThread输出：" + i);
        }
    }
}

在定义一个测试类，在测试类中创建MyThread的实例对象，并启动线程

public class ThreadTest1 {
    // main方法是由一条默认的主线程负责执行。
    public static void main(String[] args) {
        // 3、创建MyThread线程类的对象代表一个线程
        Thread t = new MyThread();
        // 4、启动线程（自动执行run方法的）
        t.start(); 

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出：" + i);
        }
    }
}

打印结果如下图所示，我们会发现MyThread和main线程在相互抢夺CPU的执行权（注意：哪一个线程先执行，哪一个线程后执行，目前我们是无法控制的，每次输出结果都会不一样）

(imgs/1668047848218.png)
image

1.2 线程的创建方式二：实现Runnable接口

具体步骤如下：

  1. 先写一个Runnable接口的实现类，重写run方法(这里面就是线程要执行的代码)
  2. 再创建一个Runnable实现类的实例对象
  3. 创建一个Thread对象，把Runnable实现类的对象传递给Thread
  4. 调用Thread对象的start()方法启动线程（启动后会自动执行Runnable里面的run方法）

代码如下：先创建一个MyRunnable类实现Runnable接口：

/**
 * 1、定义一个任务类，实现Runnable接口
 */
public class MyRunnable implements Runnable{
    // 2、重写runnable的run方法
    @Override
    public void run() {
        // 线程要执行的任务。
        for (int i = 1; i <= 5; i++) {
            System.out.println("子线程输出 ===》" + i);
        }
    }
}

再写一个测试类，在测试类中创建线程对象，并执行线程：

public class ThreadTest2 {
    public static void main(String[] args) {
        // 3、创建任务对象。
        Runnable target = new MyRunnable();
        // 4、把任务对象交给一个线程对象处理。
        //  public Thread(Runnable target)
        new Thread(target).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出 ===》" + i);
        }
    }
}

如果不想创建Runnable接口的实现类，可以使用匿名内部类的方式创建实现类对象（如下面代码中的简化形式1）；又由于Runnable接口是由注释@FunctionalInterface修饰的，表明其是一个只包含一个抽象方法的接口，此时可以用lamda表达式简化匿名内部类的创建（如下面代码中的简化形式2）：

public class ThreadTest2_2 {
    public static void main(String[] args) {
        // 1、直接创建Runnable接口的匿名内部类形式（任务对象）
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程1输出：" + i);
                }
            }
        };
        new Thread(target).start();

        // 简化形式1：
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程2输出：" + i);
                }
            }
        }).start();

        // 简化形式2：
        new Thread(() -> {
                for (int i = 1; i <= 5; i++) {
                    System.out.println("子线程3输出：" + i);
                }
        }).start();

        for (int i = 1; i <= 5; i++) {
            System.out.println("主线程main输出：" + i);
        }
    }
}

1.3 线程的创建方式三：Callable接口 + FutureTask类

由于前面两种方式重写的void run() 方法均没有返回结果，故JDK5提供了Callable接口和FutureTask类来创建线程，它最大的优点就是有返回值。在Callable接口中有一个call方法，重写call方法就是线程要执行的代码，它是有返回值的

具体创建步骤如下：

  1. 先定义一个Callable接口的实现类，重写其call方法；

  2. 创建Callable实现类的实例对象；

  3. 创建FutureTask类的实例对象，将Callable实现类的实例对象传给FutureTask；

  4. 创建Thread对象，将FutureTask实例对象传给Thread；

  5. 调用Thread对象的start()方法启动线程（启动后会自动执行call方法）

    等call()方法执行完之后，会将返回值风窗到FutureTask的实例对象中；

  6. 调用FutureTask对象的get()方法获取返回结果。

代码如下：先准备一个Callable接口的实现类

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= n ; i++) {
            sum += i;
        }
        return "线程" + sum;
    }
}

再定义一个测试类，在测试类中创建线程并启动线程，还要获取返回结果：

public class ThreadTest3 {
    public static void main(String[] args) throws Exception {
        // 3、创建一个Callable的对象
        Callable<String> call = new MyCallable(100);
        // 4、把Callable的对象封装成一个FutureTask对象（任务对象）
        // 未来任务对象的作用？
        // 1、是一个任务对象，实现了Runnable对象.
        // 2、可以在线程执行完毕之后，用未来任务对象调用get方法获取线程执行完毕后的结果。
        FutureTask<String> f1  = new FutureTask<>(call);
        // 5、把任务对象交给一个Thread对象
        new Thread(f1).start();


        Callable<String> call2 = new MyCallable(200);
        FutureTask<String> f2  = new FutureTask<>(call2);
        new Thread(f2).start();


        // 6、获取线程执行完毕后返回的结果。
        // 注意：如果执行到这儿，假如上面的线程还没有执行完毕
        // 这里的代码会暂停，等待上面线程执行完毕后才会获取结果。
        String rs = f1.get();
        System.out.println(rs);

        String rs2 = f2.get();
        System.out.println(rs2);
    }
}

二、多线程的常用方法

(imgs/1668051403591.png)
image

下面代码展示这些方法的实际用法：先创建一个线程类继承Thread类：

public class MyThread extends Thread{
    public MyThread(String name){
        super(name); //1.执行父类Thread(String name)构造器，为当前线程设置名字了
    }
    @Override
    public void run() {
        //2.currentThread() 哪个线程执行它，它就会得到哪个线程对象。
        Thread t = Thread.currentThread();
        for (int i = 1; i <= 3; i++) {
            //3.getName() 获取线程名称
            System.out.println(t.getName() + "输出：" + i);
        }
    }
}

再测试类中，创建线程对象，并启动线程

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread();
        t1.setName(String name) //设置线程名称;
        t1.start();
        System.out.println(t1.getName());  //Thread-0

        Thread t2 = new MyThread("2号线程");
        // t2.setName("2号线程");
        t2.start();
        System.out.println(t2.getName()); // Thread-1

        // 主线程对象的名字
        // 哪个线程执行它，它就会得到哪个线程对象。
        Thread m = Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName()); // main

        for (int i = 1; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
        }
    }
}

执行上面代码，效果如下图所示：

(imgs/1668052028054.png)
image

join方法是让调用这个方法的线程先执行完，才会进行下一步。最后再演示一下join这个方法：写一个专门展示join方法的测试类：

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        // join方法作用：让当前调用这个方法的线程先执行完。
        Thread t1 = new MyThread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new MyThread("2号线程");
        t2.start();
        t2.join();

        Thread t3 = new MyThread("3号线程");
        t3.start();
        t3.join();
    }
}

执行效果如下图：

(imgs/1668052307537.png)
image

三、线程安全问题

3.1 线程安全问题概述

线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。

如下面取钱的案例所示。案例需求如下：

场景：小明和小红是一对夫妻，他们有一个共享账户，余额是10万元，小红和小明同时来取钱，并且2人各自都在取钱10万元，可能出现什么问题呢？

小明和小红假设都是一个线程，本类每个线程都应该执行完三步操作：

1. 判断余额是否足够；
2. 取出10万元；
3. 更新账户余额。

但是真实执行过程可能是下面这样子的：

​ ① 小红线程只执行了判断余额是否足够（条件为true），然后CPU的执行权就被小红线程抢走了；

​ ② 小红线程也执行了判断了余额是否足够（条件也是true）, 然后CPU执行权又被小明线程抢走了；

​ ③ 小明线程由于刚才已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为0。然后CPU执行权又被小红线程抢走；

​ ④ 小红线程由于刚刚也已经判断余额是否足够了，直接执行第2步，吐出了10万元钱，此时共享账户月为-10万。

最后你会发现，在这个取钱案例中，两个人把共享账户的钱都取了10万，但问题是只有10万块钱啊！！！

3.2 线程完全问题代码演示

先定义一个共享的账户类：

public class Account {
    private String cardId; // 卡号
    private double money; // 余额。

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    // 小明 小红同时过来的
    public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        // 1、判断余额是否足够
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

再定义一个取钱的线程类：

public class DrawThread extends Thread{
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }
    @Override
    public void run() {
        // 取钱(小明，小红)
        acc.drawMoney(100000);
    }
}

最后，再写一个测试类，在测试类中创建两个线程对象：

public class ThreadTest {
    public static void main(String[] args) {
         // 1、创建一个账户对象，代表两个人的共享账户。
        Account acc = new Account("ICBC-110", 100000);
        // 2、创建两个线程，分别代表小明 小红，再去同一个账户对象中取钱10万。
        new DrawThread(acc, "小明").start(); // 小明
        new DrawThread(acc, "小红").start(); // 小红
    }
}

运行程序，执行效果如下。你会发现两个人都取了10万块钱，余额为-10完了：

(imgs/1668059997020.png)
image

3.3 线程同步

为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。

3.2.1 同步代码块

同步代码块的作用就是把访问共享数据的代码锁起来，以此保证线程安全。语法如下：

//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
    //...访问共享数据的代码...
}

这里强调一下锁对象如何选择：

  1. 建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
  2. 对于实例方法，建议使用this作为锁对象
  3. 对于静态方法，建议把类的字节码(类名.class)当做锁对象

使用同步代码块，来解决前面代码里面的线程安全问题。我们只需要修改DrawThread类中的代码即可，代码如下：

// 小明 小红线程同时过来的
public void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    // this正好代表共享资源！
    synchronized (this) {
        if(this.money >= money){
            System.out.println(name + "来取钱" + money + "成功！");
            this.money -= money;
            System.out.println(name + "来取钱后，余额剩余：" + this.money);
        }else {
            System.out.println(name + "来取钱：余额不足~");
        }
    }
}

3.2.2 同步方法

同步方法，就是把整个方法给锁住，一个线程调用这个方法时，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。

// 同步方法
public synchronized void drawMoney(double money) {
    // 先搞清楚是谁来取钱？
    String name = Thread.currentThread().getName();
    // 1、判断余额是否足够
    if(this.money >= money){
        System.out.println(name + "来取钱" + money + "成功！");
        this.money -= money;
        System.out.println(name + "来取钱后，余额剩余：" + this.money);
    }else {
        System.out.println(name + "来取钱：余额不足~");
    }
}

注意：

同步方法有没有锁对象？锁对象是谁？

​ 同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。

​ - 对于实例方法，锁对象其实是this（也就是方法的调用者）

​ - 对于静态方法，锁对象时类的字节码对象（类名.class）

最终，总结一下同步代码块和同步方法有什么区别？

​ 不存在哪个好与不好，只是一个锁住的范围大，一个范围小

​ - 同步方法是将方法中所有的代码锁住

​ - 同步代码块是将方法中的部分代码锁住

3.2.3 Lock锁

Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。语法如下：

1.首先在线程类成员变量的位置，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
	private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
	 lk.lock(); // 加锁
	 //...中间是被锁住的代码...
	 lk.unlock(); // 解锁

使用Lock锁改写前面DrawThread中取钱的方法，代码如下：

// 创建了一个锁对象
private final Lock lk = new ReentrantLock();

public void drawMoney(double money) {
        // 先搞清楚是谁来取钱？
        String name = Thread.currentThread().getName();
        try {
            lk.lock(); // 加锁
            // 1、判断余额是否足够
            if(this.money >= money){
                System.out.println(name + "来取钱" + money + "成功！");
                this.money -= money;
                System.out.println(name + "来取钱后，余额剩余：" + this.money);
            }else {
                System.out.println(name + "来取钱：余额不足~");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lk.unlock(); // 解锁
        }
    }
}

四、线程通信（了解）

首先，什么是线程通信呢？

  • 当多个线程共同操作共享资源时，线程间通过某种方式互相告知自己的状态，以相互协调，避免无效的资源挣抢。

线程通信的常见模式：是生产者与消费者模型

  • 生产者线程负责生成数据
  • 消费者线程负责消费生产者生成的数据
  • 注意：生产者生产完数据后应该让自己等待，通知其他消费者消费；消费者消费完数据之后应该让自己等待，同时通知生产者生成。

比如下面案例中，有3个厨师（生产者线程），两个顾客（消费者线程）。

(imgs/1668064583299.png)
image

接下来，我们先分析一下完成这个案例的思路:

1.先确定在这个案例中，什么是共享数据？
	答：这里案例中桌子是共享数据，因为厨师和顾客都需要对桌子上的包子进行操作。

2.再确定有那几条线程？哪个是生产者，哪个是消费者？
	答：厨师是生产者线程，3条生产者线程； 
	   顾客是消费者线程，2条消费者线程
	   
3.什么时候将哪一个线程设置为什么状态
	生产者线程(厨师)放包子：
		 1)先判断是否有包子
		 2)没有包子时，厨师开始做包子, 做完之后把别人唤醒，然后让自己等待
		 3)有包子时，不做包子了，直接唤醒别人、然后让自己等待
		 	
	消费者线程(顾客)吃包子：
		 1)先判断是否有包子
		 2)有包子时，顾客开始吃包子, 吃完之后把别人唤醒，然后让自己等待
		 3)没有包子时，不吃包子了，直接唤醒别人、然后让自己等待

按照上面分析的思路写代码。先写桌子类，代码如下:

public class Desk {
    private List<String> list = new ArrayList<>();

    // 放1个包子的方法
    // 厨师1 厨师2 厨师3
    public synchronized void put() {
        try {
            String name = Thread.currentThread().getName();
            // 判断是否有包子。
            if(list.size() == 0){
                list.add(name + "做的肉包子");
                System.out.println(name + "做了一个肉包子~~");
                Thread.sleep(2000);

                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }else {
                // 有包子了，不做了。
                // 唤醒别人, 等待自己
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 吃货1 吃货2
    public synchronized void get() {
        try {
            String name = Thread.currentThread().getName();
            if(list.size() == 1){
                // 有包子，吃了
                System.out.println(name  + "吃了：" + list.get(0));
                list.clear();
                Thread.sleep(1000);
                this.notifyAll();
                this.wait();
            }else {
                // 没有包子
                this.notifyAll();
                this.wait();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

再写测试类，在测试类中，创建3个厨师线程对象，再创建2个顾客对象，并启动所有线程，代码如下:

public class ThreadTest {
    public static void main(String[] args) {
        //   需求：3个生产者线程，负责生产包子，每个线程每次只能生产1个包子放在桌子上
        //      2个消费者线程负责吃包子，每人每次只能从桌子上拿1个包子吃。
        Desk desk  = new Desk();

        // 创建3个生产者线程（3个厨师）
        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师1").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师2").start();

        new Thread(() -> {
            while (true) {
                desk.put();
            }
        }, "厨师3").start();

        // 创建2个消费者线程（2个吃货）
        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货1").start();

        new Thread(() -> {
            while (true) {
                desk.get();
            }
        }, "吃货2").start();
    }
}

执行上面代码，运行结果如下：你会发现多个线程相互协调执行，避免无效的资源挣抢，结果如下：

厨师1做了一个肉包子~~
吃货2吃了：厨师1做的肉包子
厨师3做了一个肉包子~~
吃货2吃了：厨师3做的肉包子
厨师1做了一个肉包子~~
吃货1吃了：厨师1做的肉包子
厨师2做了一个肉包子~~
吃货2吃了：厨师2做的肉包子
厨师3做了一个肉包子~~
吃货1吃了：厨师3做的肉包子

五、线程池

5.1 线程池概述

线程池就是一个可以复用线程的技术。要理解什么是线程复用技术，我们先得看一下不使用线程池会有什么问题，理解了这些问题之后，我们在解释线程复用同学们就好理解了：

假设：用户每次发起一个请求给后台，后台就创建一个新的线程来处理，下次新的任务过来肯定也会创建新的线程，如果用户量非常大，创建的线程也讲越来越多。然而，创建线程是开销很大的，并且请求过多时，会严重影响系统性能。

而使用线程池，就可以解决上面的问题。如下图所示，线程池内部会有一个容器，存储几个核心线程，假设有3个核心线程，这3个核心线程可以处理3个任务。但是任务总有被执行完的时候，假设第1个线程的任务执行完了，那么第1个线程就空闲下来了(不会被销毁)，有新的任务时，空闲下来的第1个线程可以去执行其他任务。依此类推，这3个线程可以不断的复用，也可以执行很多个任务。

(imgs/1668065892511.png)
(imgs/1668066073126.png)

image

image

所以，线程池就是一个线程复用技术，它可以提高线程的利用率。

5.2 创建线程池

在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。

语法如下图：

(imgs/1668066279649.png)
image

用上面语法创建一个线程池实例对象，代码如下：

ExecutorService pool = new ThreadPoolExecutor(
						3,	//核心线程数有3个
    					5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    					8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    					TimeUnit.SECONDS,//时间单位（秒）
    					new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    					Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    					new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
						);

关于线程池，我们需要注意下面的两个问题：

  1. 临时线程什么时候创建？

核心线程都在忙、任务队列满了、并且还可以创建临时线程，若此时有新任务，就会创建临时线程

  1. 什么时候开始拒绝新的任务？

核心线程和临时线程都在忙、任务队列也满了，新任务过来时才会开始拒绝任务

5.3 线程池执行Runnable任务

创建好线程池之后，接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。

下图中的execute方法可以用来执行Runnable任务：

(imgs/1668066844202.png)
image

先准备一个实现Runnable接口的线程任务类

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        // 任务是干啥的？
        System.out.println(Thread.currentThread().getName() + " ==> 输出666~~");
        //为了模拟线程一直在执行，这里睡久一点
        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

下面是执行Runnable任务的代码，注意阅读注释，对照着前面的7个参数理解，代码如下：

ExecutorService pool = new ThreadPoolExecutor(
    3,	//核心线程数有3个
    5,  //最大线程数有5个。   临时线程数=最大线程数-核心线程数=5-3=2
    8,	//临时线程存活的时间8秒。 意思是临时线程8秒没有任务执行，就会被销毁掉。
    TimeUnit.SECONDS,//时间单位（秒）
    new ArrayBlockingQueue<>(4), //任务阻塞队列，没有来得及执行的任务在，任务队列中等待
    Executors.defaultThreadFactory(), //用于创建线程的工厂对象
    new ThreadPoolExecutor.CallerRunsPolicy() //拒绝策略
);

Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
//下面4个任务在任务队列里排队
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);

//下面2个任务，会被临时线程的创建时机了
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);

执行上面的代码，结果输出如下：

(imgs/1668067745116.png)
image

5.4 线程池执行Callable任务

callable任务相对于Runnable任务来说，就是多了一个返回值。执行Callable任务需要用到下图中的submit方法：

(imgs/1668067798673.png)
image

先准备一个实现了Callable接口的线程任务类，代码如下：

public class MyCallable implements Callable<String> {
    private int n;
    public MyCallable(int n) {
        this.n = n;
    }

    // 2、重写call方法
    @Override
    public String call() throws Exception {
        // 描述线程的任务，返回线程执行返回后的结果。
        // 需求：求1-n的和返回。
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    }
}

再准备一个测试类，在测试类中创建线程池，并执行callable任务，代码如下：

public class ThreadPoolTest2 {
    public static void main(String[] args) throws Exception {
        // 1、通过ThreadPoolExecutor创建一个线程池对象。
        ExecutorService pool = new ThreadPoolExecutor(
            3,
            5,
            8,
            TimeUnit.SECONDS, 
            new ArrayBlockingQueue<>(4),
            Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.CallerRunsPolicy());

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        // 3、执行完Callable任务后，需要获取返回结果。
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

执行后，结果如下图所示：

(imgs/1668067964048.png)
image

5.5 线程池工具类（Executors）

Executors是用与快速创建线程池的工具类。它提供了方法可以创建各种特定的线程池。如下图所示：

(imgs/1668068110593.png)
image

使用上面Executors中的方法创建线程池，代码如下：

public class ThreadPoolTest3 {
    public static void main(String[] args) throws Exception {
        // 1、通过Executors创建一个线程池对象。
        ExecutorService pool = Executors.newFixedThreadPool(17);
        // 老师：核心线程数量到底配置多少呢？？？
        // 计算密集型的任务：核心线程数量 = CPU的核数 + 1
        // IO密集型的任务：核心线程数量 = CPU核数 * 2

        // 2、使用线程处理Callable任务。
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
    }
}

但实际开发过程中不推荐使用Executors创建线程池。原因如下图：这是《阿里巴巴Java开发手册》提供的强制规范要求。

(imgs/1668068399363.png)
image

六、补充知识

5.1 并发和并行

  • 并发：微观上串行，宏观上并行；
  • 并行：微观上并行，宏观上并行；

在现代多核CPU计算机系统中，多个线程都是并发和并行同时存在的。

5.2 java中的线程生命周期

在Thread类中有一个嵌套的枚举类叫Thread.Status，这里面定义了线程的6中状态。如下图所示：

(imgs/1668069923403.png)
image

1、NEW: 新建状态，线程还没有启动
2、RUNNABLE: 可以运行状态，线程调用了start()方法后处于这个状态
3、BLOCKED: 锁阻塞状态，没有获取到锁处于这个状态
4、WAITING: 无限等待状态，线程执行时被调用了wait方法处于这个状态
5、TIMED_WAITING: 计时等待状态，线程执行时被调用了sleep(毫秒)或者wait(毫秒)方法处于这个状态
6、TERMINATED: 终止状态, 线程执行完毕或者遇到异常时，处于这个状态。

这几种状态之间切换关系如下图所示：

(imgs/1668070204768.png)
image

七、乐观锁

  • 悲观锁：严格控制共享资源同一时刻只能由一个线程访问

  • 乐观锁：不限制共享资源的访问，等出现线程安全问题在进行处理

前面我们学习的锁方法都是悲观锁，乐观锁的学习，可以看黑马的这个视频：黑马程序员：乐观锁

比如整数乐观锁：

AtomicInteger count = new AtomicInteger();    // 默认初始化的话，count的值为0

如下代码演示了100个线程，每个线程执行一次+1操作：正确的情况下最终结果count的值应该为100；

先定义一个任务类：

public class MyRunnable implements Runnable{
    // 整型乐观锁：由原子类实现
    AtomicInteger count = new AtomicInteger(0);

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "做了一次加法操作，加完之后值为：" + count.incrementAndGet());
    }
}

再创建100个线程执行，代码如下：

public class Test {
    public static void main(String[] args) {
        Runnable target = new MyRunnable();

        for (int i = 0; i < 100; i++) {
            new Thread(target).start();
        }
    }
}

最后count的结果如下应该就是预期的100。

count.incrementAndGet()其底层原理是在线程访问共享资源时，如此时某个线程访问到内存中的count=10，然后进行加一操作得到11，然后再去内存中找到count地址，确认此时的count的内存地址的内容是10，若此时地址里的内容还是10，则把内容修改成11；若此时count的内存地址中的内容不是10，而是变成了12，则表明此时其他线程在该线程修改内容之前已经修改了，此时再把count的内存址内容修改成11就会出现线程安全问题，于是底层会放弃此次修改，然后重新访问count的内存地址的内容，直到进行修改时确认当前count的内存地址的内容依然还是自己之前取到的，才会修改成功。

标签：Thread,money,线程,创建,new,多线程,public
From： https://www.cnblogs.com/sunjuil/p/17777611.html

相关文章

  • 多线程编程同步：Posix信号量
    信号量的定义IPC是进程间通信（interprocesscommunication）的简称。狭义上，IPC主要用于进程间；广义上，IPC可用于进程间或线程间。Posix消息队列、Posix信号量和Posix共享内存区合称为“PosixIPC”.信号量（semaphore）是一种用于提供不同进程间或一个给定进程的不同线程间同步手段。......
  • Java 多线程例子1 小例子
    学习的张孝祥的《Java就业培训教程》觉得讲的不错，是比较好的入门教程吧。下面是最简单的例子。publicclassThreadDemo{ publicstaticvoidmain(String[]args){ newTestThread().start(); while(true){ System.out.println("main():"+Thread.currentThread().getN......
  • Java 多线程例子2 前台线程（用户线程） 后台线程（守护线程 ） setDaemon
    1，setDaemon（true）后就是后台线程（守护线程），反之就是前台线程（用户线程）2，后台线程和前台线程的区别：在java程序中如果所以的前台线程都已经退出，所有的后台线程自动退出。TestThread为后台线程：publicclassThreadDemo{ publicstaticvoidmain(String[]args){ Threadt=newTes......
  • GIL全局解释器锁、互斥锁、线程队列、进程池和线程池的使用、多线程爬取网页、协程理
    进程和线程的比较进程的开销比线程的开销大很多进程之间的数据是隔离的，但是，线程之间的数据不隔离多个进程之间的线程数据不共享----->还是让进程通信(IPC)------->进程下的线程也通信了---->队列GIL全局解释器锁(重要理论)Python在设计之初就考虑到要在主循环中，同时只有一......
  • Java有哪些保证原子性的方法？如何保证多线程下i++ 结果正确？什么是原子操作类？
    使用循环原子类，例如AtomicInteger，实现i++原子操作使用juc包下的锁，如ReentrantLock，对i++操作加锁lock.lock()来实现原子性使用synchronized，对i++操作加锁原子操作类当程序更新一个变量时，如果多线程同时更新这个变量，可能得到期望之外的值，比如变量i=1，A线程更新i+1，B线程也更新i+1，经......
  • [Java]Java初学之多线程01
    Intro写完上一篇博客就立刻开始了Java多线程的学习学习这个东西还是得趁热打铁，一两天不学感觉知识要从脑子里流走了（不要啊（≧□≦）ノ）就是这样，这篇文章主要集中在Java多线程的相关内容，可能会分篇写。正文程序(Program)、进程(Process)、线程(Thread)在正式学习内容之前，我觉得先......
  • 使用单例模式进行多线程编程
    title:aliases:tags:-工程技术-cpp/并发编程category:-方法stars:url:creation-time:2023-10-1914:32modification-time:2023-10-1915:27:06[[单例模式]]简而言之就是程序中的某个类只能实例化一个对象。因为对象只有一个，在不同线程中实例化的时候，实......
  • python脚本中应用多线程和多进程理解
    脚本内容因为要读取mongo某个全表数据（亿级别），有个字段有索引且是一堆多的关系从其他表读取所有这个字段（十万级别），再读取大表因为数据量大所以写个测试，从中拿出几条去大表查询（每次读到十万级别数据）多线程和多进程的影响不使用多线/进程file=open('test2.csv','w')content......
  • 多线程
    #include<stdio.h>#include<pthread.h>#include<Windows.h>staticintg_num=0;staticintg_c=0;pthread_mutex_tgMutex_num=PTHREAD_MUTEX_INITIALIZER;pthread_mutex_tgMutex_c=PTHREAD_MUTEX_INITIALIZER;void*test(void*para)......
  • 【玩转Python系列【小白必看】Python多线程爬虫：下载表情包网站的图片
    前言本文主要介绍了使用Python编写的多线程爬虫程序，用于下载表情包网站上的图片。通过解析网页内容和使用XPath定位，可以获取到图片的URL，并将其保存到本地。1.导入模块和库importrequestsfromlxmlimportetreefromthreadingimportThreadfromqueueimportQueueim......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99