【Java并发编程一】线程安全问题

1.多线程的实现

多线程有两种实现方式：

1.1.继承Thread类 =>示例：A a=new A(); a.start();

 

1.2.实现Runnable接口 =>示例：A a=new A(); new Thread(A,自定义线程名称).start();

 

其实Thread和Runnable都实现了run方法，这种操作模式其实就是代理模式

获取当前线程名称：Thread.currentThread().getName()

调用线程是thread.start(),真正执行线程是 thread.run()

具体代码：

 /**
  * 继承Thread类
  * @date 2019/3/29 11:19
  */
 public class SimpleThread extends Thread{

     @Override
     public void run() {
         super.run();
         Thread thread = Thread.currentThread();
         System.out.println("Thread =>当前执行的线程为："+thread.getName());
     }
 }

 /**
  * 实现Runnable接口
  * @date 2019/3/29 11:28
  */
 public class SimpleRunnable implements Runnable {

     @Override
     public void run() {
          Thread thread = Thread.currentThread();
          System.out.println("Runnable =>当前执行的线程为："+thread.getName());
     }
 }

 public class TestMain {

     /**执行线程示例1*/
     private static void callSimpleThread(){
         int index=10;
         for (int i = 0; i < index; i++) {
              Thread thread=new SimpleThread();
              thread.start();
         }
     }

     /**执行线程示例1*/
     private static void callSimpleRunnable(){
         int index=10;
         for (int i = 0; i < index; i++) {
             SimpleRunnable simpleRunnable=new SimpleRunnable();
             new Thread(simpleRunnable,"Runnable-"+i).start();
         }
     }

     public static void main(String[] args) {

         callSimpleThread();

         callSimpleRunnable();
     }

 }

2.多线程安全问题

2.1线程不安全示例

多线程最容易产生的一个问题就是线程安全问题，下面使用一个卖票的例子来体现。

场景描述：现在有两个售票员，一共卖10张车票

 public class SellTicket extends Thread {

     private static int NUMBER = 10;
     public SellTicket(String name) {
         super(name);
     }

     @Override
     public void run() {
         String s = "线程：" + Thread.currentThread().getName();

         while (NUMBER > 0) {
             int i = NUMBER--;
             System.out.println(s + " => 卖了第" + i + "号票");
         }

         System.out.println(s + ",票已经卖完");
         super.run();
     }

     public static void main(String[] args) {

         SellTicket thread1 = new SellTicket("售票员A");
         thread1.start();

         SellTicket thread2 = new SellTicket("售票员B");
         thread2.start();

     }

 }

执行结果如下：

我们发现售票员A 和售票员B都卖了10号票，这就是线程不安全导致的结果

2.2线程不安全解决方法

方案一：使用同步代码解决
格式：synchronized(锁对象){需要被同步的代码}
锁对象可以为this锁，也可以自定义对象锁

方案二：使用同步函数解决
同步函数就是使用synchronized修饰一个函数

下面采用同步代码块解决

 public class SafetySellTicket extends Thread {

     private static int NUMBER = 10;

     @Override
     public  void run() {
         String s = "线程：" + Thread.currentThread().getName();

         while (NUMBER > 0) {
             synchronized (this) {
                 if (NUMBER > 0) {
                     int i = NUMBER--;
                     System.out.println(s + " => 卖了第" + i + "号票");
                 } else {
                     System.out.println(s + ",票已经卖完");
                     break;
                 }

             }
         }
         super.run();
     }

     public static void main(String[] args) {

         SafetySellTicket thread1 = new SafetySellTicket();
         thread1.start();

         SafetySellTicket thread2 = new SafetySellTicket();
         thread2.start();

     }

 }