线程安全的解决方法(一)--同步代码块Synchronized

线程安全问题的解决方法--线程同步

解决办法： 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行

 

 

解决方法一：同步代码块 Synchronized

同步代码块：

synchronized (对象){

// 需要被同步的代码；

}

说明：1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
*       2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
*       3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
*          要求：多个线程必须要共用同一把锁。
*
*       补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

 

 

同步原理：

三个线程同一时间只有一个可以进入到同步代码块Synchronized中来进行，谁先抢到了锁（同步监视器），谁就可以进入代码块中去执行

 

 

 

用同步代码块解决 实现Runnable接口来创建线程  的线程安全问题

package thread;

class window implements Runnable{

    private int ticket = 100;
    Object obj = new Object();

    @Override
    public void run() {

        //Object obj = new Object();如果锁定义在这个位置，两个线程就不是共用一个obj了。

        synchronized(obj)
            while (true) {
                synchronized(obj){
                    if (ticket > 0) {
                        System.out.println(Thread.currentThread().getName() + "票号为：" + ticket);
                        ticket--;
                    } else {
                        System.out.println("没票啦");
                        break;
                    }
                }
            }
        
    }

}


public class test{
    public static void main(String[] args){
        window T = new window();
        Thread t1 = new Thread(T);
        Thread t2 = new Thread(T);
        t1.start();
        t2.start();
    }
}

• 注意锁这个对象定义的位置，代码中obj定义在了属性这里，在 window T = new window(); 时就已经被定义出来了。两个线程t1 t2共用一个obj
• 如果定义在注释那个位置，那么 t1.start();  t2.start(); 在执行时分别都创建了一个obj。
• synchronized (obj) 这里的锁obj 还可以替换为this，对于t1和t2，this也是唯一的

5.同步的方式，解决了线程的安全问题。---好处
*    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

 

 

用同步代码块解决 继承Thread类来创建线程  的线程安全问题

package thread;

class myThread1 extends Thread{

    private static int ticket = 100;
    static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "票号为：" + ticket);
                    ticket--;
                } else {
                    System.out.println("没票啦");
                    break;
                }
            }
        }


    }
}

public class thread{
    public static void main(String[] args){

        myThread1 t1 = new myThread1();
        myThread1 t2 = new myThread1();
        myThread1 t3 = new myThread1();

        t1.start();
        t2.start();
        t3.start();


    }
}

• 注意synchronized (obj){}所包住的需要被同步的代码不能多也不能少，例如下面这种情况就会导致只有一个窗口把所有票都抢了

• package thread;
  
  class myThread1 extends Thread{
  
      private static int ticket = 100;
      static Object obj = new Object();
  
      @Override
      public void run() {
          synchronized (obj) {
              while (true) {
                      if (ticket > 0) {
                          System.out.println(Thread.currentThread().getName() + "票号为：" + ticket);
                          ticket--;
                      } else {
                          System.out.println("没票啦");
                          break;
                      }
                  }
          
              }
  
      }
  }
  
  public class thread{
      public static void main(String[] args){
  
          myThread1 t1 = new myThread1();
          myThread1 t2 = new myThread1();
          myThread1 t3 = new myThread1();
  
          t1.start();
          t2.start();
          t3.start();
  
  
      }
  }
  
  
  
  
  
  
  
  

   

• 这里与用同步代码块解决 实现Runnable接口来创建线程  的线程安全问题的代码不同的是，锁obj定义时要定义为static。因为t1 t2 t3在创建时new了三次，如果不是static类型就会创建三个obj

• synchronized (obj) 这里的锁obj 还可以替换为myThread1.class  万物皆对象，类也是对象。 而且虽然创建三个线程时new myThread1();new了三次，但是类只会加载一次，也就是说t1 t2 t3共用一个myThread1.class