JAVA 多线程（十八）

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量853 收藏 19
点赞数 20
分类专栏： JAVA 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljs__123/article/details/136014042
版权

多线程（十八）

进程：进程是程序的基本执行实体。
线程：一个进程可以包括多个线程，线程是操作系统能够进行运算调度的最小单位，它是进程中实际运作单位，简单理解为在应用软件中互相独立，可以同时运行的功能。
有了多线程，可让程序同时做多件事情，多线程可以提高效率，若想让多个事情同时运行就需要用到多线程，比如：软件中的耗时操作，所有的聊天软件，所有的服务器。
并发：在同一时刻，有多个指令在单个CPU上交替执行。
并行：在同一时刻，有多个指令在单个CPU上同时执行。
线程的调度

  1. 抢占式调度：指优先让可运行池中优先级高的线程占用CPU，优先级并不绝对，只不过优先级越高，占用CPU的概率越高。
  2. 分时调度：又称非抢占式调度，指让所有线程轮流获得cpu的使用权。

多线程的实现方式

线程是程序中的执行线程，java虚拟机允许应用程序并发地运行多个执行线程。

  1. 继承Thread类的方式进行实现
  2. 实现Runnable接口的方式进行实现
  3. 利用Callable接口和Future接口方式实现

继承Thread类

步骤：

  1. 定义一个类继承Thread
  2. 重写run方法
  3. 创建子类对象，并启动线程（利用start方法启动，run方法会自动调用）

范例:

//Test.java
public class Test {
    public static void main(String[] args) {
        Function f1=new Function();
        Function f2=new Function();
        f1.setName("线程1");
        f2.setName("线程2");
        f1.start();
        f2.start();
    }
}
//Function.java
public class Function extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+"执行");
        }
    }
}
/*
线程2执行
线程2执行
线程2执行
线程2执行
线程1执行
线程2执行
线程1执行
线程2执行
线程2执行
线程2执行
线程2执行
线程2执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
*/

实现Runnable接口

步骤：

  1. 定义一个类实现Runnable接口
  2. 重写里面的run方法
  3. 创建自己类的对象
  4. 创建一个Thread类的对象，并开启线程

范例：

//Test.java
public class Test {
    public static void main(String[] args) {
        //创建function对象，表示多线程要执行的任务
        Function f=new Function();
        //创建线程对象
        Thread t1=new Thread(f);
        Thread t2=new Thread(f);
        //给线程设置名字
        t1.setName("线程1");
        t2.setName("线程2");
        //开启线程
        t1.start();
        t2.start();
    }
}
//Function.java
public class Function implements Runnable {
    //线程要执行的代码
    @Override
    public void run() {
        //获取当前线程的对象
        Thread t=Thread.currentThread();
        for (int i=0;i<10;i++) {
            System.out.println(t.getName()+"执行");
        }
    }
}
/*
线程1执行
线程1执行
线程2执行
线程1执行
线程2执行
线程2执行
线程2执行
线程2执行
线程2执行
线程2执行
线程2执行
线程2执行
线程2执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
线程1执行
*/

Callable接口和Future接口方式实现

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

步骤：

  1. 创建一个类MyCallable类实现Callable接口，其中泛型便是多线程运行的结果类型
  2. 重写Call方法（具有返回值，表示多线程运行的结果）
  3. 创建MyCallable的对象（表示多线程要执行的任务）
  4. 创建FutureTask的对象（作用为管理多线程运行的结果）
  5. 创建Thread对象，并启动（表示线程）

范例：

//MyCallable.java

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int i=1;i<=100;i++){
            sum+=i;
        }
        return sum;
    }
}

//

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建一个类MyCallable实现Callable接口
        MyCallable mc=new MyCallable();
        //创建FutureTask的对象（作用为管理多线程运行的结果）
        FutureTask<Integer> ft=new FutureTask<>(mc);
        //创建线程的对象
        Thread t=new Thread(ft);
        //启动线程
        t.start();
        //获取多线程运行的结果
        Integer integer = ft.get();
        System.out.println(integer);

    }
}
/*
5050
*/

三种方式对比

  • 继承Thread类

    • 优点：编程比较简单，可直接使用Thread类的方法
    • 缺点：可扩展性差，不能再继承其他类

  • 实现Runnable接口

    • 优点：扩展性强，实现该接口的同时还可以继承其他类
    • 缺点：编程相对复杂，不能直接使用Thread类中的方法

  • 实现Callable接口

    • 优点：扩展性强，实现该接口的同时还可以继承其他类，可获取多线程运行的结果
    • 缺点：编程相对复杂，不能直接使用Thread类中的方法

常见成员方法

getName

String getName()

说明：返回此线程的名称，若没有给线程设置名字，线程也是有默认名字的，默认名字格式：Thread-X（X序号，从0开始）

setName

void setName(String name)

说明：设置线程名字（构造方法也可以设置名字）

currentThread

static Thread currentThread()

说明：获取当前线程的对象，当虚拟机启动后，会自动启用多条线程，其中一条叫做main线程，它的作用便是调用main方法，并执行其中代码。

sleep

static void sleep(long time)

说明：让线程休眠指定的时间，单位为毫秒（1秒等于1000毫秒），哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间。

setPriority

setPriority(int newPriority)

说明：设置线程的优先级，优先级最高位10，最低为1，默认为5

getPriority

final int getPriority()

说明：获取线程的优先级

setDaemon

final void setDaemon(boolean on)

说明：设置守护线程，当其他非守护线程执行完毕后，守护线程会陆续结束。

yield

public static void yield()

说明：出让线程/礼让线程

join

public final void join()

说明：插入线程/插队线程。表示把调用该方法的线程插入到当前线程之前

范例

//MyThread.java
public class MyThread extends Thread {
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(getName());
    }
}
//Test.java
public class Test {
    public static void main(String[] args){
        //getName默认
        MyThread mt1=new MyThread();
        mt1.start();
        //构造方法设置
        MyThread mt2=new MyThread("线程2");
        mt2.start();
        //通过setName设置后的getName
        MyThread mt3=new MyThread();
        mt3.setName("线程3");
        mt3.start();

        //currentThread
        Thread t=Thread.currentThread();
        System.out.println(t.getName());
    }
}
/*
main
线程2
Thread-0
线程3
*/

//MyThread.java
public class MyThread implements Runnable {
    @Override
    public void run() {
        for (int i=0;i<10;i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
//Test.java
public class Test {
    public static void main(String[] args){
        MyThread mt=new MyThread();
        Thread t1=new Thread(mt,"线程1");
        Thread t2=new Thread(mt,"线程2");
        System.out.println("默认");
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        System.out.println("修该后");
        t1.setPriority(1);
        t2.setPriority(10);
        System.out.println(t1.getPriority());
        System.out.println(t2.getPriority());
        t1.start();
        t2.start();
    }
}
/*
默认
5
5
修该后
1
10
线程2:0
线程2:1
线程1:0
线程2:2
线程1:1
线程1:2
线程2:3
线程1:3
线程2:4
线程1:4
线程2:5
线程2:6
线程2:7
线程2:8
线程2:9
线程1:5
线程1:6
线程1:7
线程1:8
线程1:9
*/

//Test.java
public class Test {
    public static void main(String[] args){
        MyThread1 mt1=new MyThread1();
        MyThread2 mt2=new MyThread2();
        mt1.setName("守护线程");
        mt2.setName("非守护线程");
        mt1.setDaemon(true);
        mt1.start();
        mt2.start();
    }
}
//MyThread1.java
public class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+i);
        }
    }
}
//MyThread2.java
public class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+i);
        }
    }
}
/*
守护线程0
非守护线程0
非守护线程1
守护线程1
非守护线程2
守护线程2
非守护线程3
非守护线程4
非守护线程5
非守护线程6
非守护线程7
非守护线程8
非守护线程9
守护线程3
守护线程4
守护线程5
守护线程6
守护线程7
*/

//Test.java
public class Test {
    public static void main(String[] args){
        MyThread mt1=new MyThread();
        MyThread mt2=new MyThread();
        mt1.setName("线程一");
        mt2.setName("线程二");
        mt1.start();
        mt2.start();
    }
}
//MyThread.java
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+i);
            Thread.yield();
        }
    }
}
/*
线程一0
线程二0
线程二1
线程一1
线程一2
线程一3
线程二2
线程一4
线程一5
线程二3
线程二4
线程二5
线程一6
线程二6
线程一7
线程二7
线程一8
线程一9
线程二8
线程二9
*/

//Test.java
public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt=new MyThread();
        mt.setName("线程一");
        mt.start();
        mt.join();

        for (int i = 0; i < 10; i++) {
            System.out.println("main线程"+i);
        }
    }
}
//MyThread.java
public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(getName()+i);
            Thread.yield();
        }
    }
}
/*
线程一0
线程一1
线程一2
线程一3
线程一4
线程一5
线程一6
线程一7
线程一8
线程一9
main线程0
main线程1
main线程2
main线程3
main线程4
main线程5
main线程6
main线程7
main线程8
main线程9
*/

线程的生命周期

新建状态NEW：创建线程对象。调用start方法后变成就绪状态

就绪状态RUNNABLE：有执行资格，没执行权。不停的抢CPU

阻塞状态BLOCKED：无法获得锁对象

等待状态WAITING：wait方法

计时状态TIMED_WAITING：sleep方法

死亡状态TERMINATED：若run执行完毕，线程死亡，变成垃圾

同步代码块

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

特点：

  1. 锁默认打开，有一个线程进去，锁自动关闭
  2. 里面的代码全部执行完毕，线程出来，锁自动打开

格式：

synchronized(锁){
	操作共享数据的代码
}
//锁对象一定要是唯一的，一般写当前类的字节码文件。

范例：

//某电影院目前上映的甲电影，共有10张票，有3个窗口售卖，设计一个程序模拟该电影院买票
//Test.java
public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt1=new MyThread();
        mt1.setName("窗口1");

        MyThread mt2=new MyThread();
        mt2.setName("窗口2");

        MyThread mt3=new MyThread();
        mt3.setName("窗口3");

        mt1.start();
        mt2.start();
        mt3.start();

    }
}
//MyThread.java
public class MyThread extends Thread{
    static int ticketNum=1;
    @Override
    public void run() {
        while (true) {
            synchronized (MyThread.class) {
                if (ticketNum <=10) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName() + "卖出第" + ticketNum + "张票");
                    ticketNum++;

                } else {
                    break;
                }
            }
        }
    }
}
/*
窗口1卖出第1张票
窗口1卖出第2张票
窗口3卖出第3张票
窗口3卖出第4张票
窗口3卖出第5张票
窗口3卖出第6张票
窗口3卖出第7张票
窗口3卖出第8张票
窗口2卖出第9张票
窗口2卖出第10张票
*/

同步方法

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

格式：

修饰符 synchronized 返回值类型 方法名(方法参数){…}

特点：

  1. 同步方法是锁住方法里面所有的代码
  2. 锁对象不能自己指定。
    • 非静态方法：this
    • 静态方法：当前类的字节码文件对象

范例：

//某电影院目前上映的甲电影，共有10张票，有3个窗口售卖，设计一个程序模拟该电影院买票,同步方法实现
//Test.java
1public class Test {
    public static void main(String[] args){
        MyThread myThread=new MyThread();
        Thread t1=new Thread(myThread);
        Thread t2=new Thread(myThread);
        Thread t3=new Thread(myThread);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
//MyThread.java
public class MyThread implements Runnable{
    int ticketNum=0;
    @Override
    public void run() {
        while (true){
            if (method()){
                break;
            }
        }
    }
    private synchronized boolean method(){
        if(ticketNum==10){
            return true;
        }else {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            ticketNum++;
            System.out.println(Thread.currentThread().getName()+ "卖出第" + ticketNum + "张票");
        }
        return false;
    }
}
/*
窗口1卖出第1张票
窗口1卖出第2张票
窗口1卖出第3张票
窗口1卖出第4张票
窗口1卖出第5张票
窗口1卖出第6张票
窗口1卖出第7张票
窗口1卖出第8张票
窗口3卖出第9张票
窗口2卖出第10张票
*/

lock锁

Lock中提供获得锁和释放锁的方法。

void lock(); 获得锁

void unlock(); 释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。

ReentrantLock的构造方法：

ReentrantLock(); 创建一个ReentrantLock的实例。

范例：

//某电影院目前上映的甲电影，共有10张票，有3个窗口售卖，设计一个程序模拟该电影院买票,Lock实现
//Test.java
public class Test {
    public static void main(String[] args) throws InterruptedException {
        MyThread mt1=new MyThread();
        mt1.setName("窗口1");

        MyThread mt2=new MyThread();
        mt2.setName("窗口2");

        MyThread mt3=new MyThread();
        mt3.setName("窗口3");

        mt1.start();
        mt2.start();
        mt3.start();

    }
}
//MyThread.java
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyThread extends Thread{
    static int ticketNum=1;
    static Lock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            try {
                if (ticketNum <=100) {
                    Thread.sleep(10);
                    System.out.println(getName() + "卖出第" + ticketNum + "张票");
                    ticketNum++;
                } else {
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }

        }
    }
}

注：写锁的时候不要让锁嵌套，否则可能会死锁。

等待唤醒机制

方式一

等待唤醒机制(生产者消费者模式)是多个线程之间的一种协作机制。

思路:

此处将消费者比喻成吃货，生产者比喻成厨师。

  • 消费者：消费数据
    1. 判断桌子上是否有食物
    2. 若无，等待
    3. 若有，开吃
    4. 吃完后，唤醒厨师继续做
  • 生产者：生产数据
    1. 判断桌子上是否有食物
    2. 若有，等待
    3. 若无，做饭
    4. 把食物放到桌子上
    5. 唤醒等待的消费者开吃
常见方法
wait

void wait()

说明：当前线程等待，直到被其他线程唤醒

notify

void notify()

说明：随机唤醒单个线程

notifyAll

void notifyAll()

说明：唤醒所有线程

范例
//Desk.java
public class Desk {
    public static int count=10;//吃货能吃的饭的数量
    public static Object lock=new Object();//锁
    public static int state=0;//桌子的状态，若无食物为0，若有食物为1
}
//Cookie.java
public class Cookie extends Thread {
    /*
    1. 循环
    2.同步代码块
    3.判断共享数据是否到了尽头（到了尽头）
    4.判断共享数据是否到了尽头（没到尽头，执行核心逻辑）
    */
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else {//判断桌子上是否有食物
                    if(Desk.state==0){//无食物，厨师做饭
                        System.out.println("厨师做饭");
                        //桌子上有了食物，状态设为1
                        Desk.state=1;
                        //唤醒吃货
                        Desk.lock.notifyAll();
                    }else{//若有，则等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}
//Foodie.java
public class Foodie extends Thread{
    /*
    1. 循环
    2.同步代码块
    3.判断共享数据是否到了尽头（到了尽头）
    4.判断共享数据是否到了尽头（没到尽头，执行核心逻辑）
    */
    @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) {
                            e.printStackTrace();
                        }
                    }else{//若有，开吃
                        //先将饭量-1
                        Desk.count--;
                        System.out.println("吃货还能吃"+Desk.count+"顿饭");
                        //吃饭后，桌子上没有事物，状态设为0
                        Desk.state=0;
                        //唤醒厨师
                        Desk.lock.notifyAll();
                    }
                }
            }
        }
    }
}
//Test.java
public class Test {
    public static void main(String[] args) {
        Cookie cookie=new Cookie();
        Foodie foodie=new Foodie();
        cookie.start();
        foodie.start();
    }
}
/*
厨师做饭
吃货还能吃9顿饭
厨师做饭
吃货还能吃8顿饭
厨师做饭
吃货还能吃7顿饭
厨师做饭
吃货还能吃6顿饭
厨师做饭
吃货还能吃5顿饭
厨师做饭
吃货还能吃4顿饭
厨师做饭
吃货还能吃3顿饭
厨师做饭
吃货还能吃2顿饭
厨师做饭
吃货还能吃1顿饭
厨师做饭
吃货还能吃0顿饭
*/

方式二

阻塞队列实现等待唤醒机制。

阻塞队列继承结构

阻塞队列实现Iterable,Collection,Queue,BlockingQueue接口，有两个实现类:

  1. ArrayBlockingQueue：底层是数组，有界
  2. LinkedBlockingQueue：底层是链表，无界，但不是真的无界，最大为int最大值

思路：

此处将消费者比喻成吃货，生产者比喻成厨师。

  • 厨师
    1. 构造方法中接收一个阻塞队列对象
    2. run方法中循环向阻塞队列添加食物
    3. 打印添加结果
  • 吃货
    1. 构造方法中接收一个阻塞队列对象
    2. run方法中循环获取阻塞队列的食物
    3. 打印获取结果
核心方法

put(anObject)

将参数放入队列，若放不进去会堵塞。

take()

取出第一个数据，取不到会堵塞。

注：put，take方法里本身就有锁

范例
//Test.java
import java.util.concurrent.ArrayBlockingQueue;

public class Test {
    public static void main(String[] args){
        ArrayBlockingQueue<String> abq=new ArrayBlockingQueue<>(1);//创建阻塞对象，并设置容量
        Cookie cookie=new Cookie(abq);
        Foodie foodie=new Foodie(abq);
        cookie.start();
        foodie.start();

    }
}
//Cookie.java
import java.util.concurrent.ArrayBlockingQueue;

public class Cookie extends Thread{
    ArrayBlockingQueue<String> abq;
    public Cookie(ArrayBlockingQueue<String> abq){
        this.abq=abq;
    }

    @Override
    public void run() {
        while (true){
            try {
                abq.put("食物");
                System.out.println("厨师放食物");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//Foodie.java
import java.util.concurrent.ArrayBlockingQueue;

public class Foodie extends Thread{
    ArrayBlockingQueue<String> abq;
    public Foodie(ArrayBlockingQueue<String> abq){
        this.abq=abq;
    }
    @Override
    public void run() {
        while (true){
            try {
                String s=abq.take();
                System.out.println(s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

练习

例1

/*
假设：100元分成了三个红包（均为整数），有5人去抢
其中红包是共享数据。
5个人5条线程
打印结果如下：
XXX抢到了XX元
XXX抢到了XX元
XXX抢到了XX元
XXX没抢到
XXX没抢到
*/
//Test.java
public class Test {
    public static void main(String[] args) {
        RedPackage rp1=new RedPackage();
        RedPackage rp2=new RedPackage();
        RedPackage rp3=new RedPackage();
        RedPackage rp4=new RedPackage();
        RedPackage rp5=new RedPackage();

        rp1.setName("线程1");
        rp2.setName("线程2");
        rp3.setName("线程3");
        rp4.setName("线程4");
        rp5.setName("线程5");

        rp1.start();
        rp2.start();
        rp3.start();
        rp4.start();
        rp5.start();
    }
}
//RedPackage.java
import java.util.Random;

public class RedPackage extends Thread{
    static int sum=100;
    static int count=3;
    @Override
    public void run() {
        synchronized (RedPackage.class){
            if(count==0){
                System.out.println(getName()+"没抢到");
            }else{
                if(count==1){
                    int money=sum;
                    System.out.println(getName()+"抢到了"+money+"元");
                }else{
                    Random r=new Random();
                    int money=r.nextInt(sum-(count-1))+1;
                    System.out.println(getName()+"抢到了"+money+"元");
                    sum=sum-money;
                }
                count--;
            }
        }
    }
}
/*
线程1抢到了3元
线程5抢到了40元
线程4抢到了57元
线程3没抢到
线程2没抢到
*/

例2

/*
有一个抽奖池，该抽奖池中存放了奖励的金额，该抽奖池中的奖项为10,5,20,50,100,200,500,800,2,80,300,700
创建两个抽奖箱（线程）设置线程名分别为“抽奖箱1”和“抽奖箱2”
随机从抽奖池中获取奖项元素并打印在控制台上，格式如下：
在此次抽奖过程中，抽奖箱2共产生6个奖项
分别为:800,10,80,500,700,2最高奖项为800元，总计额为2092元
在此次抽奖过程中，抽奖箱1共产生6个奖项
分别为:5,100,50,300,20,200最高奖项为300元，总计额为675元
在此次抽奖过程中，抽奖箱2中产生最大奖项，该奖项金额为800元
*/
//Lottery.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.Callable;

public class Lottery implements Callable<Integer> {
    ArrayList<Integer> moneyBox;
    public Lottery(ArrayList<Integer> moneyBox){
        this.moneyBox=moneyBox;
    }
    @Override
    public Integer call() throws Exception {
        ArrayList<Integer> list=new ArrayList<>();
        int sum=0;
        while (true){
            synchronized (Lottery.class) {
                if (moneyBox.size() == 0) {
                    print(list,Collections.max(list),sum);
                    break;
                } else {
                    Collections.shuffle(moneyBox);
                    int money = moneyBox.remove(0);
                    list.add(money);
                    sum+=money;
                }
            }
            Thread.sleep(10);
        }
        if(list.size()==0){
            return null;
        }
        return Collections.max(list);
    }
    private static void print(ArrayList<Integer> list,int max,int sum){
        System.out.println("在此次抽奖过程中，"+Thread.currentThread().getName()+"共产生"+list.size()+"个奖项");
        System.out.print("分别为:");
        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i));
            if(i< list.size()-1){
                System.out.print(",");
            }
        }
        System.out.println("最高奖项为"+max+"元，总计额为"+sum+"元");
    }
}
//Test.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ArrayList<Integer> moneyBox=new ArrayList<>();
        Collections.addAll(moneyBox,10,5,20,50,100,200,500,800,2,80,300,700);
        Lottery lottery=new Lottery(moneyBox);
        FutureTask<Integer> ft1=new FutureTask<>(lottery);
        FutureTask<Integer> ft2=new FutureTask<>(lottery);

        Thread t1=new Thread(ft1);
        Thread t2=new Thread(ft2);
        t1.setName("抽奖箱1");
        t2.setName("抽奖箱2");
        t1.start();
        t2.start();
        int money;
        String name;
        if(ft1.get()>ft2.get()){
            money=ft1.get();
            name=t1.getName();
        }else{
            money=ft2.get();
            name=t2.getName();
        }
        System.out.println("在此次抽奖过程中，"+name+"产生最大值，最大值金额为"+money);

    }
}
/*
在此次抽奖过程中，抽奖箱1共产生6个奖项
分别为:80,100,50,5,10,700最高奖项为700元，总计额为945元
在此次抽奖过程中，抽奖箱2共产生6个奖项
分别为:500,200,20,300,2,800最高奖项为800元，总计额为1822元
在此次抽奖过程中，抽奖箱2产生最大值，最大值金额为800

*/

线程池

核心原理

  1. 创建一个池子，池子中是空的
  2. 提交任务时，池子会创建新的线程对象，执行完毕后，线程归还给池子，下次再提交任务时，不需创建新线程，直接复用已有的线程即可
  3. 若提交任务时，池子中没有空闲线程，也无法创建新的线程，任务便会排队等待

代码实现步骤：

  1. 创建线程池
  2. 提交任务
  3. 所有的任务全部执行完毕，关闭线程池

Executors

Executors：线程池的工具类通过调用方法返回不同类型的线程池对象。

newCachedThreadPool

格式：

public static ExecutorsService newCachedThreadPool()

说明：创建一个几乎没有上限的线程池

newFixedThreadPool

格式：

public static ExecutorsService newFixedThreadPool(int nThreads)

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

范例

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

public class Test {
    public static void main(String[] args) throws InterruptedException {
    	//1.获取线程池对象
        ExecutorService pool= Executors.newCachedThreadPool();
        //2.提交任务
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        //3.销毁线程池
        pool.shutdown();
    }
}
//MyRunnable.java
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
/*
pool-1-thread-1
pool-1-thread-3
pool-1-thread-5
pool-1-thread-2
pool-1-thread-4
*/

//MyRunnable.java
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//Test.java
public class Test {
    public static void main(String[] args) throws InterruptedException {
    	//1.获取线程池对象
        ExecutorService pool= Executors.newFixedThreadPool(3);
        //2.提交任务
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());
        //3.销毁线程池
        pool.shutdown();
    }
}
/*
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-1
pool-1-thread-2
*/

自定义线程

步骤

  1. 创建一个空的池子

  2. 有任务提交时，线程池会创建线程去执行任务，执行完毕归还线程。

注：不断提交任务，会有以下三个临界点

  1. 当核心线程满时，在提交任务就会排队
  2. 当核心线程满，队满时，会创建临时线程
  3. 当核心线程满，队满时，临时线程满时，会触发任务拒绝策略
核心元素（参数）
  1. 核心线程数量（不少于0）
  2. 线程池中最大线程数量（最大数量>=核心线程数量）
  3. 空闲时间（值）（不能小于0）
  4. 空闲时间（单位）（用TimeUnit绑定）
  5. 阻塞队列（不能为null）
  6. 创建线程工厂（不能为null）
  7. 要执行的任务过多时的解决方案（不能为null）
范例
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args){
        ThreadPoolExecutor pool=new ThreadPoolExecutor(
                3,//核心线程数量（不少于0）
                6,//线程池中最大线程数量（最大数量>=核心线程数量）
                60,//空闲时间（值）（不能小于0）
                TimeUnit.SECONDS,//空闲时间（单位）（用TimeUnit绑定）
                new ArrayBlockingQueue<>(3),//阻塞队列（不能为null）
                Executors.defaultThreadFactory(),//创建线程工厂（不能为null）
                new ThreadPoolExecutor.AbortPolicy()//要执行的任务过多时的解决方案（不能为null）
        );
    }
}

线程池多大合适

最大并行数：可用Runtime.getRuntime().availableProcessors()返回当前电脑的最大并行数

CPU密集型运算：即项目中CPU计算居多，线程池大小=最大并行数+1  

I/O密集型运算：即项目中文件操作居多，线程池大小=最大并行数*期望CPU利用率*（总时间（CPU计算时间+等待时间）/CPU计算时间）
ljs__123
关注
  • 20
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
Java多线程详解及示例
07-20
Java多线程编程是提升程序性能和响应性的关键技术。理解多线程的概念，掌握线程的创建、同步、通信、死锁避免等核心知识点，以及合理使用线程池，对于编写高效、稳定的并发程序至关重要。通过实践，开发者可以更好地...
Java多线程下载器
09-26
Java多线程下载器是一种利用Java编程语言实现的高效文件下载工具，它通过将大文件分割成多个部分并同时下载，显著提高了下载速度。在Java中实现多线程下载器涉及许多关键概念和技术，包括线程、并发控制、网络I/O...
Java多线程程序设计
02-19
Java多线程程序设计，源代码注释讲解都包括
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1113
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 383
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 430
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 773
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 761
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 108
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 319
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 961
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 813
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
学习笔记---java篇（0723）
m0_70630166的博客
07-23 672
java、数据类型、循环、选择等
4.Jmeter接口性能测试
weixin_43444329的博客
07-23 453
系统用户数：软件系统注册的用户总数（要注意初始化环境）在线用户数：某段视角内访问用户数，这些用户只是咋先，不一定同时做某一件事情。（初始化环境（warm up热机：让系统接近运行的系统，让系统运行更快 磁盘->内存））并发用户数：某一个时间同时向系统提交请求的用户数，场景不一定是同一个。：测试web系统的性能，支持多少并发？在确定并发用户数之前，必须先对用户的业务进行分解，分析出其中的典型业务场景（用户最常用、最关注的业务操作）然后基于场景获得其并发用户数。
java包装类型缓存简单探究-Integer为例
保存我对一些技术的思考
07-22 710
java包装类缓存机制-Integer为例
Java的集合框架（Collection Framework）中的Iterator接口详解
m0_49013185的博客
07-22 615
在Java中，将Iterator定义为接口是一种设计上的选择，目的是提供一个统一的迭代机制，使不同类型的集合都能以一致的方式进行遍历。以下是将Iterator以下是IteratorE next();将Iterator定义为接口的主要目的是提供一个统一、灵活且可扩展的迭代机制。通过这种方式，Java集合框架能够支持多种类型的集合，并且客户端代码能够以一致的方式使用这些集合。这种设计不仅简化了集合的使用，还提高了代码的可维护性和可扩展性。
Java反序列化漏洞CC2利用链注入内存马
道阻且长，行则将至。
07-20 654
本文从 0 到 1 介绍了 TemplatesImpl 链的基础原理，同时介绍其在 Fastjson 反序列化漏洞利用过程中的应用，最后介绍了 Java 反序列化漏洞 CC2 链中对 TemplatesImpl 链的集成，以及如何通过 CC2 链注入恶意类与 Java 内存马。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值