• Java基础（四）

    前言：本博客主要涉及java编程中的线程、多线程、生成者消费者模型、死锁。

    目录

    线程多线程

    线程同步

    synchronized

    Lock锁

    线程通信

    生产者消费者模型

    线程池

    使用线程池处理Runnable任务

    使用线程池处理Callable任务

    Excutors

    悲观锁

    乐观锁

    并发VS并行

    线程的生命周期

    线程多线程

    创建一个简单的线程

    获取执行当前代码的线程名：Thread.currentThread().getName()

    开启线程：对象名.start()

    守护线程 优先级

    1. //1.创建一个继承于Thread类的子类
    2. class MyThread extends Thread {
    3.     //2.重写Thread类的run()
    4.     @Override
    5.     public void run() {
    6.         for (int i = 0; i < 100; i++) {
    7.                 System.out.println(Thread.currentThread().getName() + ":" + i);
    8.         }
    9.     }
    10. }
    11.  
    12. public class ThreadTest {
    13.     public static void main(String[] args) {
    14.         MyThread t1 = new MyThread();
    15.         t1.start();
    16.     }
    17. }
    1. package learn12;
    2.  
    3. class MyRunnable implements Runnable {
    4.     @Override
    5.     public void run() {
    6.         for (int i = 1; i <= 5; i++) {
    7.             System.out.println("子线程输出：" + i);
    8.         }
    9.     }
    10. }
    11.  
    12. public class MyThreadTest2 {
    13.     public static void main(String[] args) {
    14.         Runnable target = new MyRunnable();
    15.         new Thread(target).start();
    16.         for (int i = 1; i <= 5; i++) {
    17.             System.out.println("主线程main输出：" + i);
    18.         }
    19.  
    20.     }
    21.  
    22. }

    线程安全

    例子：多个人同时去一个账户里取钱，被取出后，不能再取出钱。但多个线程执行时，在访问时，账户里有钱的，但实际上已经被其他用户取走，此时再取钱就会引发数据不安全的问题。

    使用多线程时，每个线程都对数据进行修改，如何来保证数据的安全性？

    1. package learn12;
    2.  
    3. public class Account {
    4.     private String cardId;
    5.     private double money;
    6.  
    7.     public Account() {
    8.     }
    9.  
    10.     public Account(String cardId, double money) {
    11.         this.cardId = cardId;
    12.         this.money = money;
    13.     }
    14.  
    15.     public String getCardId() {
    16.         return cardId;
    17.     }
    18.  
    19.     public void setCardId(String cardId) {
    20.         this.cardId = cardId;
    21.     }
    22.  
    23.     public double getMoney() {
    24.         return money;
    25.     }
    26.  
    27.     public void setMoney(double money) {
    28.         this.money = money;
    29.     }
    30.  
    31.     public void drawMoney(double money) {
    32.         String name = Thread.currentThread().getName();
    33.             if (this.money >= money) {
    34.                 System.out.println(name + "来取钱" + money + "成功！");
    35.                 this.money -= money;
    36.                 System.out.println(name + "来取钱，此时剩余：" + this.money);
    37.             } else {
    38.                 System.out.println(name + "来取钱，但余额不足");
    39.             }
    40.     }
    41. }
    1. package learn12;
    2.  
    3. public class DrawThread extends Thread {
    4.     private Account acc;
    5.  
    6.     public DrawThread(Account acc, String name) {
    7.         super(name);
    8.         this.acc = acc;
    9.     }
    10.  
    11.     @Override
    12.     public void run() {
    13.         acc.drawMoney(100000);
    14.     }
    15. }
    1. package learn12;
    2.  
    3. public class ThreadTest {
    4.     public static void main(String[] args) {
    5.         Account acc = new Account("ICBC-100", 100000);
    6.         new DrawThread(acc, "小明").start();
    7.         new DrawThread(acc, "小红").start();
    8.         new DrawThread(acc, "小李").start();
    9.     }
    10. }

    线程同步

    使用了加锁的机制

    synchronized

    用到了同步控制关键字synchronized

    用其修饰成员方法，被修饰的方法，在同一时间，只能被一个线程执行

    1. //同步方法
    2. public synchronized void drawMoney(double money) {
    3.         String name = Thread.currentThread().getName();
    4. //同步代码块
    5.         synchronized (this) {
    6.             if (this.money >= money) {
    7.                 System.out.println(name + "来取钱" + money + "成功！");
    8.                 this.money -= money;
    9.                 System.out.println(name + "来取钱，此时剩余：" + this.money);
    10.             } else {
    11.                 System.out.println(name + "来取钱，但余额不足");
    12.             }
    13.         }
    14.     }

    Lock锁

    注意：解锁要放在finally里，以便程序出错时，可以解锁。

    1. package learn12;
    2.  
    3. import java.util.concurrent.locks.Lock;
    4. import java.util.concurrent.locks.ReentrantLock;
    5.  
    6. public class Account {
    7.     private String cardId;
    8.     private double money;
    9.     //创建Lock锁对象
    10.     private final Lock lk = new ReentrantLock();
    11.  
    12.     public Account() {
    13.     }
    14.  
    15.     public Account(String cardId, double money) {
    16.         this.cardId = cardId;
    17.         this.money = money;
    18.     }
    19.  
    20.     public String getCardId() {
    21.         return cardId;
    22.     }
    23.  
    24.     public void setCardId(String cardId) {
    25.         this.cardId = cardId;
    26.     }
    27.  
    28.     public double getMoney() {
    29.         return money;
    30.     }
    31.  
    32.     public void setMoney(double money) {
    33.         this.money = money;
    34.     }
    35.  
    36.     public void drawMoney(double money) {
    37.         String name = Thread.currentThread().getName();
    38.         //加锁
    39.         lk.lock();
    40.         try {
    41.             if (this.money >= money) {
    42.                 System.out.println(name + "来取钱" + money + "成功！");
    43.                 this.money -= money;
    44.                 System.out.println(name + "来取钱，此时剩余：" + this.money);
    45.             } else {
    46.                 System.out.println(name + "来取钱，但余额不足");
    47.             }
    48.         } catch (Exception e) {
    49.             e.printStackTrace();
    50.         } finally {
    51.             //解锁
    52.             lk.unlock();
    53.         }
    54.  
    55.     }
    56. }
    57.

    线程通信

    生产者线程负责生产数据

    消费者线程负责消费生产者产生的数据

    生产者消费者模型

    1. package learn12;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class Desk {
    7.     private List list = new ArrayList<>();
    8.  
    9.     public synchronized void put() {
    10.         try {
    11.             String name = Thread.currentThread().getName();
    12.             if (list.size() == 0) {
    13.                 list.add(name + "做的肉包子");
    14.                 System.out.println(name + "做了一个肉包子");
    15.                 Thread.sleep(2000);
    16.                 //唤醒别人 等待自己
    17.                 this.notifyAll();
    18.                 this.wait();
    19.             } else {
    20.                 //唤醒别人 等待自己
    21.                 this.notifyAll();
    22.                 this.wait();
    23.             }
    24.         } catch (InterruptedException e) {
    25.             e.printStackTrace();
    26.         }
    27.     }
    28.  
    29.     public synchronized void get() {
    30.         try {
    31.             String name = Thread.currentThread().getName();
    32.             if (list.size() == 1) {
    33.                 System.out.println(name + "吃了：" + list.get(0));
    34.                 list.clear();
    35.                 Thread.sleep(1000);
    36.                 //唤醒别人 等待自己
    37.                 this.notifyAll();
    38.                 this.wait();
    39.             } else {
    40.                 //唤醒别人 等待自己
    41.                 this.notifyAll();
    42.                 this.wait();
    43.             }
    44.         } catch (InterruptedException e) {
    45.             e.printStackTrace();
    46.         }
    47.  
    48.     }
    49. }
    1. package learn12;
    2.  
    3. public class ThreadTest4 {
    4.     public static void main(String[] args) {
    5.         Desk desk = new Desk();
    6.         //生产者线程
    7.  
    8.         new Thread(() -> {
    9.             while (true) {
    10.                 desk.put();
    11.             }
    12.         }, "厨师1").start();
    13.         new Thread(() -> {
    14.             while (true) {
    15.                 desk.put();
    16.             }
    17.         }, "厨师2").start();
    18.         new Thread(() -> {
    19.             while (true) {
    20.                 desk.put();
    21.             }
    22.         }, "厨师3").start();
    23.         //消费者线程
    24.         new Thread(() -> {
    25.             while (true) {
    26.                 desk.get();
    27.             }
    28.         }, "吃货1").start();
    29.         new Thread(() -> {
    30.             while (true) {
    31.                 desk.get();
    32.             }
    33.         }, "吃货2").start();
    34.     }
    35. }

    线程池

    线程池就是一个可以复用线程的技术。

    使用线程池的必要性：

    用户发起一个请求，后台就需要创建一个新线程。不使用线程池，会产生大量的线程，会损害系统的性能。

    线程池可以固定线程和执行任务的数量，可以避免系统瘫痪和线程耗尽的风险。

    创建线程池

    临时线程什么时候创建？

    新任务提交时，发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时会创建临时线程。

    什么时候可以拒绝新任务？

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

    使用线程池处理Runnable任务

    1. package learn12;
    2.  
    3. public class MyRunnableLearn implements Runnable {
    4.     @Override
    5.     public void run() {
    6.         System.out.println(Thread.currentThread().getName() + "==>输出666");
    7.         try {
    8.             Thread.sleep(Integer.MAX_VALUE);
    9.         } catch (InterruptedException e) {
    10.             e.printStackTrace();
    11.         }
    12.     }
    13. }
    1. package learn12;
    2.  
    3. import java.util.concurrent.*;
    4.  
    5. public class ThreadPoolTest {
    6.     public static void main(String[] args) {
    7.         //创建线程池对象
    8. //        new ThreadPoolExecutor(
    9. //                                int corePoolSize,
    10. //                                int maximumPoolSize,
    11. //                                long keepAliveTime,
    12. //                                TimeUnit unit,
    13. //                                BlockingQueue workQueue,
    14. //                                ThreadFactory threadFactory,
    15. //                                RejectedExecutionHandler handler
    16. //        )
    17.         ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
    18.                 TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
    19.                 new ThreadPoolExecutor.AbortPolicy());
    20.         Runnable target = new MyRunnableLearn();
    21.         pool.execute(target);
    22.         pool.execute(target);
    23.         pool.execute(target);
    24.  
    25.         pool.execute(target);
    26.         pool.execute(target);
    27.         pool.execute(target);
    28.         pool.execute(target);
    29.  
    30.         pool.execute(target);
    31.         pool.execute(target);
    32.         //都满了 拒绝新任务
    33.         pool.execute(target);
    34. //        pool.shutdownNow();
    35.         //pool.shutdown();
    36.     }
    37. }

    使用线程池处理Callable任务

    1. package learn12;
    2.  
    3. import java.util.concurrent.Callable;
    4.  
    5. public class MyCallable implements Callable {
    6.     private int n;
    7.  
    8.     public MyCallable(int n) {
    9.         this.n = n;
    10.     }
    11.  
    12.     @Override
    13.     public String call() throws Exception {
    14.         int sum = 0;
    15.         for (int i = 1; i <= n; i++) {
    16.             sum += i;
    17.         }
    18.         return Thread.currentThread().getName() + "求出了1-" + n + "的和是：" + sum;
    19.     }
    20. }
    1. package learn12;
    2.  
    3. import java.util.concurrent.*;
    4.  
    5. public class ThreadPoolTest2 {
    6.     public static void main(String[] args) throws Exception {
    7.         ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
    8.                 TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
    9.                 new ThreadPoolExecutor.CallerRunsPolicy());
    10.         //使用线程池处理Callbable任务
    11.         Future f1 = pool.submit(new MyCallable(100));
    12.         Future f2 = pool.submit(new MyCallable(200));
    13.         Future f3 = pool.submit(new MyCallable(300));
    14.         //复用前面的线程
    15.         Future f4 = pool.submit(new MyCallable(400));
    16.         System.out.println(f1.get());
    17.         System.out.println(f2.get());
    18.         System.out.println(f3.get());
    19.         System.out.println(f4.get());
    20.     }
    21. }

     

    Excutors

    大型并发系统环境中使用Excutors如果不注意可能会出现系统风险。

    核心线程数

    计算密集型任务：核心线程数量 = CPU核数+1

    IO密集型任务：核心线程数量 = CPU核数*2

    1. package learn12;
    2.  
    3. import java.util.concurrent.*;
    4.  
    5. public class ThreadPoolTest2 {
    6.     public static void main(String[] args) throws Exception {
    7.         //通过Executors创建一个线程池对象
    8.         ExecutorService pool = Executors.newFixedThreadPool(3);
    9.         Executors.newSingleThreadExecutor();
    10.         //使用线程池处理Callbable任务
    11.         Future f1 = pool.submit(new MyCallable(100));
    12.         Future f2 = pool.submit(new MyCallable(200));
    13.         Future f3 = pool.submit(new MyCallable(300));
    14.         //复用前面的线程
    15.         Future f4 = pool.submit(new MyCallable(400));
    16.         System.out.println(f1.get());
    17.         System.out.println(f2.get());
    18.         System.out.println(f3.get());
    19.         System.out.println(f4.get());
    20.     }
    21. }

    悲观锁

    一开始就加锁，每次只能一个线程进入访问完毕后，再解锁，线程安全，性能较差。

    1. package learn12;
    2.  
    3. public class MyRunnable implements Runnable {
    4.     public int count;
    5.  
    6.     @Override
    7.     public void run() {
    8.         for (int i = 0; i < 100; i++) {
    9.             System.out.println(this);
    10.             synchronized (this) {
    11.                 System.out.println("count ===>" + (++count));
    12.             }
    13.         }
    14.     }
    15. }

     

    1. package learn12;
    2.  
    3. public class Test {
    4.     public static void main(String[] args) {
    5.         Runnable target = new MyRunnable();
    6.  
    7.         for (int i = 1; i <= 100; i++) {
    8.             new Thread(target).start();
    9.         }
    10.     }
    11. }

    乐观锁

    一开始不上锁，等要出现线程安全问题时，等要出现线程安全问题时，线程安全，性能较好。

    如何实现乐观锁

    private AtomicInteger count = new AtomicInteger();

    1. package learn12;
    2.  
    3. import java.util.concurrent.atomic.AtomicInteger;
    4.  
    5. public class MyRunnable implements Runnable {
    6.     private AtomicInteger count = new AtomicInteger();
    7.     @Override
    8.     public void run() {
    9.         for (int i = 0; i < 100; i++) {
    10.             System.out.println(this);
    11.             synchronized (this) {
    12.                 System.out.println("count ===>" + count.incrementAndGet());
    13.             }
    14.         }
    15.     }
    16. }

    并发VS并行

    python进阶学习也涉及到这里的知识点。

    Python进阶（二）-CSDN博客

    进程：正在运行的程序

    线程：一个进程中可以运行多个线程

    并发：线程是由CPU调度执行的，但CPU能同时处理的线程数量有限，为了保证全部线程都能执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，好像是线程在同时执行，这就是并发。

    并行：同一时间点，任务同时地运行，比如一台电脑，有8个CPU，每个CPU的每个核心都可以独立地执行一个任务，在同一时间点，可同时执行8个任务，这时任务是同时执行，并行地运行任务。

    线程的生命周期

    New：新建

    Runnable：可运行

    Timinated：被终止

    Timed Waiting：计时等待

    Waiting：无线等待

    Blocked：阻塞

  • 相关阅读:
    使用 Qt for Android 获取并利用手机传感器数据（1）开发环境省心搭建
    配置请求头Content-Type
    使用Seata实现分布式事务
    用LeNet做CIFAR10图像分类，并用streamlit搭建成web
    安装ROS
    Leetcode44: 通配符匹配
    231 基于matlab的北斗信号数据解析
    git ssh建立连接
    flutter run长时间卡在Running Gradle task “assembleDebug“问题解决
    ChatGPT终于接上视觉能力！
  • 原文地址：https://blog.csdn.net/MRJJ_9/article/details/132053276