• 线程安全，与多线程的应用

    一、线程安全

    1.什么是线程安全

    2.用程序模拟线程安全问题

    1. public class Account {
    2.     private double money;//余额
    3.     private String cardId;//卡号
    4.  
    5.     public Account() {
    6.     }
    7.  
    8.     public Account(double money, String cardId) {
    9.         this.money = money;
    10.         this.cardId = cardId;
    11.     }
    12.     public void drawMoney(double money){
    13.         //先搞清楚是谁来取钱
    14.         String name = Thread.currentThread ().getName ();
    15.         //1.判断账户金额是否足够
    16.         if (this.money>=money){
    17.             System.out.println (name+"开始取钱");
    18.             this.money-=money;
    19.             System.out.println (name+"取钱成功后余额为"+this.money);
    20.         }else {
    21.             System.out.println ("未取钱余额不足");
    22.         }
    23.     }
    24.  
    25.     public double getMoney() {
    26.         return money;
    27.     }
    28.  
    29.     public void setMoney(double money) {
    30.         this.money = money;
    31.     }
    32.  
    33.     public String getCardId() {
    34.         return cardId;
    35.     }
    36.  
    37.     public void setCardId(String cardId) {
    38.         this.cardId = cardId;
    39.     }
    40. }
    41.  
    42.  
    43.  
    44.  
    45. public class MyThread extends Thread{
    46.     private  Account acc;
    47.     public MyThread(Account acc,String name){
    48.         super ( name );
    49.         this.acc=acc;
    50.     }
    51.  
    52.  
    53.  
    54.     @Override
    55.     public void run() {
    56. //        if (acc.getMoney ()>=100000.0){
    57. //            System.out.println (Thread.currentThread ().getName ()+"开始取钱");
    58. //            acc.setMoney (acc.getMoney ()-100000.0);
    59. //            System.out.println (Thread.currentThread ().getName ()+"取钱成功");
    60. //        System.out.println ( Thread.currentThread ().getName ()+"取钱后账户余额"+acc.getMoney () );
    61. //        }else {
    62. //            System.out.println ("账户余额不足");
    63. //        }
    64.  
    65.         acc.drawMoney ( 100000.0 );
    66.     }
    67.  
    68. }
    69.  
    70.  
    71.  
    72. public class ThreadTest {
    73.     public static void main(String[] args) {
    74.         //1.创建一个账户类对象代表两个人的共享账户
    75.         Account acc = new Account ( 100000.0, "787878787877" );
    76.         //2.创建两个线程，分别表示小明，小红，两人同时去一个账户中取钱10w
    77.         Thread m1 = new MyThread ( acc,"小明" );
    78.         Thread m2 = new MyThread ( acc,"小红" );
    79.         m1.start ();
    80.         m2.start ();
    81.  
    82.     }
    83. }

     3.如何解决线程安全问题？

    1.线程同步

    解决方案：加锁

    2.如何实现线程同步（加锁）

    1.同步代码块

    1. public class Account {
    2.     private double money;//余额
    3.     private String cardId;//卡号
    4.  
    5.     public Account() {
    6.     }
    7.  
    8.     public Account(double money, String cardId) {
    9.         this.money = money;
    10.         this.cardId = cardId;
    11.     }
    12.     public void drawMoney(double money){
    13.         //先搞清楚是谁来取钱
    14.         String name = Thread.currentThread ().getName ();
    15.         //1.判断账户金额是否足够
    16.         synchronized (this) {//同步代码块上锁  推荐用共享资源作为锁（this）
    17.             if (this.money>=money){
    18.                 System.out.println (name+"开始取钱");
    19.                 this.money-=money;
    20.                 System.out.println (name+"取钱成功后余额为"+this.money);
    21.             }else {
    22.                 System.out.println (name+"未取钱余额不足");
    23.             }
    24.         }
    25.     }
    26.     public static void test(){ //静态方法推荐用类名上锁
    27.         synchronized (Account.class){
    28.  
    29.         }
    30.     }
    31.  
    32.     public double getMoney() {
    33.         return money;
    34.     }
    35.  
    36.     public void setMoney(double money) {
    37.         this.money = money;
    38.     }
    39.  
    40.     public String getCardId() {
    41.         return cardId;
    42.     }
    43.  
    44.     public void setCardId(String cardId) {
    45.         this.cardId = cardId;
    46.     }
    47. }
    2.同步方法

    1.   public synchronized void drawMoney(double money){
    2.         //先搞清楚是谁来取钱
    3.         String name = Thread.currentThread ().getName ();
    4.         //1.判断账户金额是否足够
    5.  
    6.             if (this.money>=money){
    7.                 System.out.println (name+"开始取钱");
    8.                 this.money-=money;
    9.                 System.out.println (name+"取钱成功后余额为"+this.money);
    10.             }else {
    11.                 System.out.println (name+"未取钱余额不足");
    12.             }
    13.  
    14.     }

    3.Lock锁

    1. import java.util.concurrent.locks.Lock;
    2. import java.util.concurrent.locks.ReentrantLock;
    3.  
    4. public class Account {
    5.     private double money;//余额
    6.     private  String cardId;//卡号
    7.     //创建一个锁对象
    8.     private final Lock lk=new ReentrantLock ();//final  保护锁对象
    9.  
    10.     public Account() {
    11.     }
    12.  
    13.     public Account(double money, String cardId) {
    14.         this.money = money;
    15.         this.cardId = cardId;
    16.     }
    17.  
    18.     public  void drawMoney(double money){
    19.         //先搞清楚是谁来取钱
    20.         String name = Thread.currentThread ().getName ();
    21.         //1.判断账户金额是否足够
    22.             lk.lock ();//加锁
    23.         try {
    24.             if (this.money>=money){
    25.                 System.out.println (name+"开始取钱");
    26.                 this.money-=money;
    27.                 System.out.println (name+"取钱成功后余额为"+this.money);
    28.             }else {
    29.                 System.out.println (name+"未取钱余额不足");
    30.             }
    31.         } catch (Exception e) {
    32.             e.printStackTrace ();
    33.         } finally {
    34.             lk.unlock ();//解锁
    35.         }
    36.         
    37.  
    38.     }
    39.     public static void test(){ //静态方法推荐用类名上锁
    40.         synchronized (Account.class){
    41.  
    42.         }
    43.     }
    44.  
    45.     public double getMoney() {
    46.         return money;
    47.     }
    48.  
    49.     public void setMoney(double money) {
    50.         this.money = money;
    51.     }
    52.  
    53.     public String getCardId() {
    54.         return cardId;
    55.     }
    56.  
    57.     public void setCardId(String cardId) {
    58.         this.cardId = cardId;
    59.     }
    60. }

    二、线程通信（前提保证线程安全）

    1.什么是线程通信

    2.代码实例

    1. public class ThreadTest {
    2.     public static void main(String[] args) {
    3.         Desk desk=new Desk ();
    4.  
    5.         //创建3个生产者线程
    6.         new Thread ( ()-> {
    7.             while (true) {
    8.                 desk.put();
    9.             }
    10.  
    11.         },"厨师1" ).start ();
    12.         new Thread ( ()-> {
    13.             while (true) {
    14.                 desk.put();
    15.             }
    16.         },"厨师2" ).start ();
    17.         new Thread ( ()-> {
    18.             while (true) {
    19.                 desk.put();
    20.             }
    21.  
    22.         },"厨师3" ).start ();
    23.  
    24.         //创建两个消费者线程
    25.        new  Thread(()->{
    26.            while (true) {
    27.                desk.get();
    28.            }
    29.        },"吃货1").start ();
    30.         new  Thread(()->{
    31.             while (true) {
    32.                 desk.get();
    33.             }
    34.         },"吃货2").start ();
    35.     }
    36.     }
    37.  
    38.  
    39.  
    40. import java.util.ArrayList;
    41. import java.util.List;
    42.  
    43. public class Desk {
    44.     private List list =new ArrayList<> ();
    45.     //放包子
    46.     //厨师1，厨师2，厨师3
    47.     public synchronized void put() {
    48.  
    49.         try {
    50.             String name = Thread.currentThread ().getName ();
    51.             //判断是否由包子
    52.             if(list.size ()==0){
    53.                 list.add ( name+"做的肉包子" );
    54.                 System.out.println (name+"做了个肉包子");
    55.                 Thread.sleep ( 2000 );
    56.              //唤醒别人，等待自己，（用锁对象调用）
    57.                 this.notifyAll ();//先唤醒 后等待
    58.                 this.wait ();
    59.             }else {
    60.                 //唤醒别人，等待自己，（用锁对象调用）
    61.                 this.notifyAll ();//先唤醒 后等待
    62.                 this.wait ();
    63.             }
    64.         } catch (Exception e) {
    65.             e.printStackTrace ();
    66.         }
    67.  
    68.     }
    69.     //取包子
    70.     //吃货1，吃货2
    71.     public synchronized void get() {
    72.         try {
    73.             String name = Thread.currentThread ().getName ();
    74.             if (list.size ()==1){
    75.                 //有包子，吃掉
    76.                 System.out.println (name+"吃了"+list.get ( 0 ));
    77.                 list.clear ();
    78.                 Thread.sleep ( 1000 );
    79.                 //唤醒别人，等待自己，（用锁对象调用）
    80.                 this.notifyAll ();//先唤醒 后等待
    81.                 this.wait ();
    82.             }else {
    83.                 //没有包子
    84.                 //唤醒别人，等待自己，（用锁对象调用）
    85.                 this.notifyAll ();//先唤醒 后等待
    86.                 this.wait ();
    87.             }
    88.         } catch (Exception e) {
    89.             e.printStackTrace ();
    90.         }
    91.  
    92.     }
    93. }
    94.  
    95.

    三、线程池

    1.什么是线程池

    2.线程池的工作原理

    控制线程的数量，也控制任务的数量，避免系统创建太多线程，耗费大量的系统资源。挺高系统性能。

    3.如何创建线程池

    1.方式1（ThreadPoolExecutor对象创建）

    1. import java.util.concurrent.*;
    2.  
    3. public class ThreadPoolTest {
    4.     public static void main(String[] args) {
    5. //            public ThreadPoolExecutor(int corePoolSize,
    6. //                                      int maximumPoolSize,
    7. //                                      long keepAliveTime,
    8. //                                      TimeUnit unit,
    9. //                                      BlockingQueue workQueue) {
    10. //                                      this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    11. //                                      Executors.defaultThreadFactory(), defaultHandler);
    12.         //1.通过ThreadPoolExecutor 创建一个线程池对象
    13.     ExecutorService pool= new ThreadPoolExecutor ( 3,5,8,TimeUnit.SECONDS,
    14.                 new ArrayBlockingQueue<> ( 4 ),Executors.defaultThreadFactory (),new ThreadPoolExecutor.AbortPolicy ());
    15.         }
    16.  
    17.  
    18.  
    19.  
    20.     }
    21.  
    22.  
    23.

    2.方式2（Executors创建）

    1. import java.util.concurrent.*;
    2.  
    3. public class Test {
    4.     public static void main(String[] args) throws Exception {
    5. //        //1.通过ThreadPoolExecutor 创建一个线程池对象
    6. //        ExecutorService pool= new ThreadPoolExecutor ( 3,5,8, TimeUnit.SECONDS,
    7. //                new ArrayBlockingQueue<> ( 4 ), Executors.defaultThreadFactory (),new ThreadPoolExecutor.AbortPolicy ());
    8.         //1-2 通过Executors创建一个线程对象。
    9.         ExecutorService pool = Executors.newFixedThreadPool ( 3 );//新建固定数量线程的线程池
    10.         //计算密集型任务：核心线程数量=CPU核数+1；
    11.         //IO密集型任务：核心线程数量=CPU核数*2；
    12.         Executors.newSingleThreadExecutor ();//新建单个线程数量的线程池
    13.         //2.使用线程处理Callable 任务类
    14.         Future f1 = pool.submit ( new MyCallable ( 100 ) );//返回未来任务对象（结果）
    15.         Future f2 = pool.submit ( new MyCallable ( 200 ) );
    16.         Future f3 = pool.submit ( new MyCallable ( 300 ) );
    17.         Future f4 = pool.submit ( new MyCallable ( 400 ) );
    18.  
    19.         System.out.println ( f1.get () );
    20.         System.out.println ( f2.get () );
    21.         System.out.println ( f3.get () );
    22.         System.out.println ( f4.get () );
    23.  
    24.  
    25.     }
    26. }

    3.注意事项

    4.线程池处理Runnable任务

    1.常用方法

    2.新任务的拒绝策略

    3.代码

    1. public class MyRunnable implements Runnable{
    2.     @Override
    3.     public void run() {
    4.         //描述任务
    5.         System.out.println (Thread.currentThread ().getName ()+"====>666");
    6.         try {
    7.             Thread.sleep ( Integer.MAX_VALUE );
    8.         } catch (InterruptedException e) {
    9.             e.printStackTrace ();
    10.         }
    11.     }
    12. }
    13.  
    14.  
    15. import java.util.concurrent.*;
    16.  
    17. public class ThreadPoolTest {
    18.     public static void main(String[] args) {
    19. //            public ThreadPoolExecutor(int corePoolSize,
    20. //                                      int maximumPoolSize,
    21. //                                      long keepAliveTime,
    22. //                                      TimeUnit unit,
    23. //                                      BlockingQueue workQueue) {
    24. //                                      this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
    25. //                                      Executors.defaultThreadFactory(), defaultHandler);
    26.         //1.通过ThreadPoolExecutor 创建一个线程池对象
    27.     ExecutorService pool= new ThreadPoolExecutor ( 3,5,8,TimeUnit.SECONDS,
    28.             new ArrayBlockingQueue<> ( 4 ),Executors.defaultThreadFactory (),new ThreadPoolExecutor.AbortPolicy ());
    29.         Runnable target = new MyRunnable ();
    30.         pool.execute ( target );//把任务交给线程池，线程池会自动创建一个新的线程，自动处理这个任务，自动执行。
    31.         pool.execute ( target );
    32.         pool.execute ( target );
    33.         //临时线程的创建时机
    34.         pool.execute ( target );//复用前面的核心线程执行任务
    35.         pool.execute ( target );
    36.         //开始进入任务队列
    37.         pool.execute ( target );
    38.         pool.execute ( target );
    39.         pool.execute ( target );
    40.         pool.execute ( target );
    41.         //开始拒绝策略（任务队列占满）
    42.         pool.execute ( target );//拒绝直接抛出错误
    43. //        pool.shutdown ();//等线程池的任务全部执行完毕后，才会关闭线程池
    44. //        pool.shutdownNow ();//立刻关闭线程池，不管任务是否执行完毕
    45.  
    46.  
    47.     }
    48.  
    49.  
    50.  
    51.  
    52.     }
    53.  
    54.  
    55.  
    56.

    5.线程池处理Callable任务

    1.常用方法

     2.代码

    1. import java.util.concurrent.Callable;
    2.  
    3. public class MyCallable implements Callable {
    4.     private int n;
    5.  
    6.     public MyCallable() {
    7.     }
    8.  
    9.     public MyCallable(int n) {
    10.         this.n = n;
    11.     }
    12.  
    13.     @Override
    14.     public String call() throws Exception {
    15.         int sum=0;
    16.         for (int i = 0; i <=n; i++) {
    17.             sum+=i;
    18.         }
    19.         return Thread.currentThread ().getName ()+"求出了1-"+n+"的和是："+sum;
    20.     }
    21. }
    22.  
    23.  
    24.  
    25. import java.util.concurrent.*;
    26.  
    27. public class Test {
    28.     public static void main(String[] args) throws Exception {
    29.         //1.通过ThreadPoolExecutor 创建一个线程池对象
    30.         ExecutorService pool= new ThreadPoolExecutor ( 3,5,8, TimeUnit.SECONDS,
    31.                 new ArrayBlockingQueue<> ( 4 ), Executors.defaultThreadFactory (),new ThreadPoolExecutor.AbortPolicy ());
    32.         //2.使用线程处理Callable 任务类
    33.         Future f1 = pool.submit ( new MyCallable ( 100 ) );//返回未来任务对象（结果）
    34.         Future f2 = pool.submit ( new MyCallable ( 200 ) );
    35.         Future f3 = pool.submit ( new MyCallable ( 300 ) );
    36.         Future f4 = pool.submit ( new MyCallable ( 400 ) );
    37.  
    38.         System.out.println ( f1.get () );
    39.         System.out.println ( f2.get () );
    40.         System.out.println ( f3.get () );
    41.         System.out.println ( f4.get () );
    42.  
    43.  
    44.     }
    45. }

    四、并发、并行

    1.进程和线程的关系

    2.什么是并发？

    3.什么是并行？

    4.多线程是怎么执行的？

    五、线程的生命周期

           人的生命周期

    sleep(不会释放锁)   wait（会释放锁）

    六、悲观锁和乐观锁

    1.悲观锁：

    一上来就加锁，没有安全感，每次只能一个线程进入访问完毕后，再关锁。线程安全，性能较差！
    1. public class MyRunnable implements Runnable{
    2.     private int count;
    3.     @Override
    4.     public void run() {
    5.         for (int i = 0; i <100; i++) {
    6.  
    7.            //悲观锁
    8.             synchronized (this) {
    9.                 System.out.println ("count=====>"+ (++count));
    10.             }
    11.  
    12.  
    13.         }
    14.  
    15.     }
    16. }
    17.  
    18.  
    19. public class Test1 {
    20.     public static int Number;
    21.     public static void main(String[] args) {
    22.         //悲观锁，乐观锁的原理
    23.         //悲观锁：一上来就加锁，没有安全感，每次只能一个线程进入访问完毕后，再关锁。线程安全，性能较差！
    24.         //乐观锁：一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题时才开始控制。线程安全，性能较好！
    25.  
    26.         //需求：1个变量，100个线程，每个线程对其加100次
    27.         Runnable target =new MyRunnable ();
    28.         for (int i = 1; i <=100; i++) {
    29.             new Thread (target).start ();
    30.         }
    31.  
    32.  
    33.     }
    34. }
    35.

    2.乐观锁

    利用原子类实现

    乐观锁：一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题时才开始控制。线程安全，性能较好！
    1. public class MyRunnable2 implements Runnable{
    2.     //乐观锁 CAS算法 比较（Compare）A（and）S（修改Set） 算法
    3.     //整数修改的乐观锁：原子类实现的
    4.     private AtomicInteger count=new AtomicInteger ();
    5.  
    6.     @Override
    7.     public void run() {
    8.         for (int i = 0; i <100; i++) {
    9.  
    10.  
    11.                 System.out.println ("count=====>"+ count.incrementAndGet ());//先加1然后再返回值
    12.  
    13.  
    14.         }
    15.  
    16.  
    17. public class Test2 {
    18.  
    19.     public static void main(String[] args) {
    20.         //悲观锁，乐观锁的原理
    21.         //悲观锁：一上来就加锁，没有安全感，每次只能一个线程进入访问完毕后，再关锁。线程安全，性能较差！
    22.         //乐观锁：一开始不上锁，认为是没有问题的，大家一起跑，等要出现线程安全问题时才开始控制。线程安全，性能较好！
    23.  
    24.         //需求：1个变量，100个线程，每个线程对其加100次
    25.         Runnable target =new MyRunnable2 ();
    26.         for (int i = 1; i <=100; i++) {
    27.             new Thread (target).start ();
    28.         }
    29.  
    30.  
    31.     }
    32. }

  • 相关阅读:
    为啥50岁以后，病就增多了？中老年人想要少生病，该做些什么？
    人类或小鼠染色体长度文件获取 hg19 mm10.chrom.sizes
    【Redis】基本操作 - 安装与配置
    【学习】一致性哈希与哈希环
    《Python》典型数据结构
    无密码解锁iPhone
    【深度学习】- NLP系列文章之 1.文本表示以及mlp来处理分类问题
    KNN分类算法
    应用案例 | 基于三维机器视觉的机器人麻袋拆垛应用解决方案
    Linux中安装mysql8
  • 原文地址：https://blog.csdn.net/m0_64703222/article/details/133124301