线程安全方式一: 同步代码块

  1. 同步代码块关键字: synchronized(同步锁) {}
  2. 将要同步的代码放在synchronized中
  3. 任意一个对象充当同步锁 Runnble接口中可以考虑使用tihs充当同步锁
  4. 多个线程必须使用统一个同步锁

  5. 缺点: 代码效率慢 代码内容只能有一个线程执行 相当于单线程 ```java /**

    • 创建人:LYY
    • 创建时间:2022/4/26

    • 同步代码块解决线程安全问题 */ public class SynchronizedTest {

      public static void main(String[] args) { TicketOne ticketOne = new TicketOne(); // 创建线程一 Thread t1 = new Thread(ticketOne); t1.setName(“线程一:”); Thread t2 = new Thread(ticketOne); t2.setName(“线程二:”); Thread t3 = new Thread(ticketOne); t3.setName(“线程三:”); t3.setPriority(10); t2.start(); t1.start(); t3.start(); }

}

class TicketOne implements Runnable{

  1. private int count = 100;
  2. Demo demo = new Demo();
  3. @Override
  4. public void run() {
  5.     while (true) {
  6.     // 同步代码块
  7.     synchronized(demo){
  8.         // 2. 将要执行的操作 卸载run方法中
  9.             if (count>0){
  10.                 System.out.println(Thread.currentThread().getName()+ "count = "+count);
  11.             } else if (count == 0){
  12.                 break;
  13.             }
  14.             try {
  15.                 Thread.sleep(100);
  16.             } catch (InterruptedException e) {
  17.                 e.printStackTrace();
  18.             }
  19.             count--;
  20.             // 放弃当前线程权
  21.             Thread.yield();
  22.         }
  23.     }
  24. }

}

  1. ```java
  2. /**
  3.  * 创建人:LYY
  4.  * 创建时间:2022/4/26
  5.  * 模拟售票
  6.  * 同100张车票 同时多个线程抢票
  7.  * 每个线程执行一次 当前票数减一
  8.  */
  10. // 1. 实现Runnable接口
  11. public class Ticket implements Runnable{
  13.     private int count = 100;
  15.     @Override
  16.     public void run() {
  17.         // 2. 将要执行的操作 卸载run方法中
  18.         while (true) {
  19.             // 同步锁
  20.             synchronized(Ticket.class){
  21.                 if (count > 0) {
  22.                     System.out.println(Thread.currentThread().getName()+ "count = "+count);
  23.                 } else if (count == 0) {
  24.                     break;
  25.                 }
  26.                 count--;
  27.             }
  28.         }
  29.     }
  30. }
  32. class TicketTest{
  34.     @Test
  35.     public void ticketTest() {
  36.         // 3. 创建Runnable接口实现类的对象
  37.         Ticket ticket = new Ticket();
  38.         // 4. 将Runnable接口实现类的对象作为参数 传递给Thread对象 创建线程
  39.         // 创建线程1
  40.         Thread t1 = new Thread(ticket);
  41.         t1.setName("线程一:");
  42.         // 创建线程2
  43.         Thread t2 = new Thread(ticket);
  44.         t2.setName("线程二:");
  45.         // 创建线程3
  46.         Thread t3 = new Thread(ticket);
  47.         t3.setName("线程三:");
  48.         t3.start();
  49.         t1.start();
  50.         t2.start();
  51.     }
  53. }

二、线程安全方式二:同步方法

  1. 创建一个方法 方法修饰符后添加synchronized关键字
  2. 将要执行(同步)的操作写在synchronized方法中
  3. run方法中调用synchronized方法
  4. synchronized方法依然存在同步锁 该对象为隐式的
  5. 继承Thread类中的同步方法需要声明为静态的 该同步方法同步锁隐式的 具体为class(.getClassz)

  6. 实现Runnable接口中的同步方法只需要添加synchronized 该方法的同步锁为隐式的 具体为this ```java /**

    • 创建人:LYY
    • 创建时间:2022/4/26

    • 使用同步方法解决继承Thread类的线程安全问题 */ public class ThreadTwo extends Thread{

      private static int count = 100; static boolean isOk = true;

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

      1.    show();

      } }

      /**

      • 同步方法 隐式的同步锁

      • 同步锁对象为class */ public static synchronized void show() {

        if (count > 0) {

        1.  System.out.println(Thread.currentThread().getName() + count);
        2.  count--;

        } else if (count == 0) {

        1.  isOk = false;

        } } }

class ThreadTwoTest{ public static void main(String[] args) { ThreadTwo t1 = new ThreadTwo(); ThreadTwo t2 = new ThreadTwo(); ThreadTwo t3 = new ThreadTwo(); t3.setName(“线程三:”); t1.setName(“线程一:”); t2.setName(“线程二:”); t1.start(); t2.start(); t3.start(); } }

  1. ```java
  3. /**
  4.  * 创建人:LYY
  5.  * 创建时间:2022/4/26
  6.  * 使用同步方法解决继承Thread类的线程安全问题
  7.  */
  8. public class ThreadTwo extends Thread{
  10.     private static int count = 100;
  11.     static boolean isOk = true;
  13.     @Override
  14.     public void run() {
  15.         while (isOk) {
  16.             show();
  17.         }
  18.     }
  20.     /**
  21.      * 同步方法 隐式的同步锁
  22.      * 同步锁对象为class
  23.      */
  24.     public static synchronized void show() {
  26.         if (count > 0) {
  27.             System.out.println(Thread.currentThread().getName() + count);
  28.             count--;
  29.         } else if (count == 0) {
  30.             isOk = false;
  31.         }
  32.     }
  33. }
  36. class ThreadTwoTest{
  37.     public static void main(String[] args) {
  38.         ThreadTwo t1 = new ThreadTwo();
  39.         ThreadTwo t2 = new ThreadTwo();
  40.         ThreadTwo t3 = new ThreadTwo();
  41.         t3.setName("线程三:");
  42.         t1.setName("线程一:");
  43.         t2.setName("线程二:");
  44.         t1.start();
  45.         t2.start();
  46.         t3.start();
  47.     }
  48. }

三、Lock锁解决线程安全问题

  1. 实现线程接口(Runnable)或类(Thread)
  2. 在线程类中创建Lock子类ReentrantLock对象
  3. 在需要同步数据前 手动使用ReentrantLock对象调用锁(lock)方法
  4. 同步数据操作接收 手动使用renntrantLock对象调用解锁(unlock)方法 ```java /**
    • 创建人:LYY
    • 创建时间:2022/4/27
    • 使用同步锁解决线程安全问题
    • 同步锁使用ReentrantLock类
      1. 在线程类中声明Lock的实现类对象 ReentrantLock
      1. 在需要同步的操作前 手动声明锁
      1. 在同步操作后 手动解锁 */ public class LockTest { }

class TicketTwo implements Runnable{

  1. private int count = 100;
  2. // 同步锁
  3. ReentrantLock reentrantLock = new ReentrantLock(true);
  5. @Override
  6. public void run() {
  8.     while (true) {
  10.         try {
  11.             // 调用锁定方法
  12.             reentrantLock.lock();
  13.             if (count > 0) {
  14.                 System.out.println(Thread.currentThread().getName() + count);
  15.             } else {
  16.                 break;
  17.             }
  18.              count--;
  19.         } finally {
  20.             // 调用解锁方法
  21.             reentrantLock.unlock();
  22.         }
  23.     }
  24. }

}

  1. ```java
  3. /**
  4.  * 创建人:LYY
  5.  * 创建时间:2022/4/27
  6.  */
  7. public class Client implements Runnable{
  9.     private int count;
  11.     /**
  12.      * 同步锁对象
  13.      */
  14.     ReentrantLock lock = new ReentrantLock();
  16.     @Override
  17.     public void run() {
  18.         for (int i = 0; i < 3; i++) {
  19.             deposit();
  20.         }
  21.     }
  23.     /**\
  24.      * 存钱方法
  25.      * 固定存款1000元
  26.      */
  27.     public void deposit() {
  29.         try {
  30.             // 同步锁锁定
  31.             lock.lock();
  32.             count +=1000;
  33.             try {
  34.                 Thread.sleep(100);
  35.             } catch (InterruptedException e) {
  36.                 e.printStackTrace();
  37.             }
  38.             System.out.println(Thread.currentThread().getName() + "存款成功! 余额:" + count);
  39.         } finally {
  40.             // 释放同步锁
  41.             lock.unlock();
  42.         }
  44.     }
  45. }
  48. class ClientTest{
  49.     public static void main(String[] args) {
  50.         // 创建对象
  51.         Client c = new Client();
  53.         // 创建客户A(线程A)
  54.         Thread thread1 = new Thread(c);
  55.         Thread thread2 = new Thread(c);
  56.         thread1.setName("线程A:");
  57.         thread2.setName("线程B:");
  59.         thread1.start();
  60.         thread2.start();
  61.     }
  62. }