线程同步

线程同步

案例 卖票

image.png

public class SellTicket implements Runnable{
   private int tickets = 100;
   //重写run方法 实现卖票
   @Override
   public void run(){
      while(true){
          if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
              sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
              tickets --;
          }
       }
   
//主程序SellTicketDemo
//创建SellTicket 对象 
SellTicket st= new SellTicket ();
//创建三个线程类的对象,把SellTicket 对象作为构造方法的参数,并且给出对应的窗口名称
Thread t1 = new Thread (st,name:"窗口1");
Thread t2 = new Thread (st,name:"窗口2");
Thread t3 = new Thread (st,name:"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();

image.png

卖票案例的思考

image.png

public class SellTicket implements Runnable{
   private int tickets = 100;
   //重写run方法 实现卖票
   @Override
   public void run(){
      while(true){
          if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
              //通过sleep方法来模拟出票时间 
              Thread.sleep(millis:100);//alt enter 捕获异常
              sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
              tickets --;
          }
       }
   
//主程序SellTicketDemo
//创建SellTicket 对象 
SellTicket st= new SellTicket ();
//创建三个线程类的对象,把SellTicket 对象作为构造方法的参数,并且给出对应的窗口名称
Thread t1 = new Thread (st,name:"窗口1");
Thread t2 = new Thread (st,name:"窗口2");
Thread t3 = new Thread (st,name:"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();

上面那个在卖票类里面加了sleep函数,会出现三个窗口卖同一张票或者卖票是负数

  • 三个窗口卖同一张票

    tickets = 100;
    t1 t2 t3
    假设t1线程抢到cpu的执行权。然后t1线程休息100ms,在t1休息的时候t2线程抢到了cpu的执行权,t2线程就开始执行,也是从tickets = 100执行,100>0,走进循环,然后t2线程休息100ms,同理,在t2休息的时候t3线程抢到了cpu的执行权,t3线程就开始执行,也是从tickets = 100执行,100>0,走进循环,然后t3线程休息100ms
    然后走到输出,假设线程按照休息的顺序醒过来,t1抢到cpu的执行权,在控制台输出窗口1正在出售第100张票,然后就应该执行tickets --,但是如果在这会正好t2抢到cpu的执行权,在控制台输出窗口2正在出售第100张票,同理,如果在这会正好t3抢到cpu的执行权,在控制台输出窗口3正在出售第100张票,
    如果这三个线程还是按照顺序来,那么这里后面就会执行三次tickets --,最终票就会变成97
  • 售票出现负数

    tickets = 1;
    t1 t2 t3
    假设t1线程抢到cpu的执行权。然后t1线程休息100ms,在t1休息的时候t2线程抢到了cpu的执行权,t2线程就开始执行,也是从tickets = 1执行,100>0,走进循环,然后t2线程休息100ms,同理,在t2休息的时候t3线程抢到了cpu的执行权,t3线程就开始执行,也是从tickets = 1执行,1>0,走进循环,然后t3线程休息100ms
    然后走到输出,假设线程按照休息的顺序醒过来,t1抢到cpu的执行权,在控制台输出窗口1正在出售第1张票,
    假设t1继续拥有cpu的使用权,则就会执行tickets --,tickets就会变成0。然后就进不去循环了,然后与此同时,正好t2抢到cpu的执行权,在控制台输出窗口2正在出售第0张票,假设t2继续拥有cpu的使用权,则就会执行tickets --,tickets就会变成-1,然后就进不去循环了,同理,正好t3抢到cpu的执行权,在控制台输出窗口2正在出售第-1张票,假设t3继续拥有cpu的使用权,则就会执行tickets --,tickets就会变成-2,

    image.png

卖票案例数据安全问题的解决

为什么出现问题(也是判断多线程程序是否会有数据安全问题的标准)

  • 是否是多线程环境
  • 是否共享数据
  • 是否有多条语句操作共享数据
public class SellTicket implements Runnable{
   private int tickets = 100;
   //重写run方法 实现卖票
   @Override
   public void run(){
      while(true){
          if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
              //通过sleep方法来模拟出票时间 
              Thread.sleep(millis:100);//alt enter 捕获异常
              sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
              tickets --;
          }
       }
   
//主程序SellTicketDemo
//创建SellTicket 对象 
SellTicket st= new SellTicket ();
//创建三个线程类的对象,把SellTicket 对象作为构造方法的参数,并且给出对应的窗口名称
Thread t1 = new Thread (st,name:"窗口1");
Thread t2 = new Thread (st,name:"窗口2");
Thread t3 = new Thread (st,name:"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();

如何解决多线程安全问题?

  • 基本思想:让程序没有安全问题的环境 一般解决上面第三个问题

怎么实现

  • 把多条语句操作共享数据的代码锁起来,然任意时刻只能有一个线程执行
  • java提供了同步代码块的方式解决

同步代码块

image.png

public class SellTicket implements Runnable{
   private int tickets = 100;
   private Object obj = new Object();//创建一个新的对象 ,不管是什么线程进来都是执行obj 是同一把锁
   //重写run方法 实现卖票
   @Override
   public void run(){
      while(true){
          synchronized(obj){
              if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
                  //通过sleep方法来模拟出票时间   
                  Thread.sleep(millis:100);//alt enter 捕获异常
                  sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                  tickets --;
              }
          }
      }
   }
}
tickets = 100;
t1 t2 t3
假设t1线程抢到cpu的执行权,t1进来胡,就会执行synchronized把这段代码锁起来,锁完之后,就会执行if语句,然后t1线程休息100ms,假设在t1休息的时候t2线程抢到了cpu的执行权,t2线程然后t2线程发现被锁住了,就只能等着,然后等t1休息好了,t1继续向下执行,在控制台输出窗口1正在出售第100张票,然后执行tickets --,tickets就会变成99,然后t1就出来了,t1出来之后这段代码的锁就会被释放了
然后三个线程再继续抢cpu的使用权

image.png

同步方法

public class SellTicket implements Runnable{
   private int tickets = 100;
   private Object obj = new Object();//创建一个新的对象 ,不管是什么线程进来都是执行obj 是同一把锁
   private int x= 0;
   //重写run方法 实现卖票
   @Override
   public void run(){
      while(true){
          if(x%2==0){
              synchronized(obj){
                  if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
                     //通过sleep方法来模拟出票时间
                     Thread.sleep(millis:100);//alt enter 捕获异常
                     sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                     tickets --;
                  }
              }
          }else{
              synchronized(obj){
                  if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
                     //通过sleep方法来模拟出票时间
                     Thread.sleep(millis:100);//alt enter 捕获异常
                     sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                     tickets --;
                  }
              }
          }
          x++;
     }
   }
}
   
//主程序SellTicketDemo
//创建SellTicket 对象 
SellTicket st= new SellTicket ();
//创建三个线程类的对象,把SellTicket 对象作为构造方法的参数,并且给出对应的窗口名称
Thread t1 = new Thread (st,name:"窗口1");
Thread t2 = new Thread (st,name:"窗口2");
Thread t3 = new Thread (st,name:"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();

上面的if和else里面控制的都是一样的也是同一把锁,可以写成方法
同步方法就是把synchronized关键字加到方法上

  • 格式:修饰符 synchronized 返回值类型 方法名(方法参数){ }
    image.png
    然后上面那个两种方法的对象应该是一样的 都是方法里的this对象
  • 同步方法的锁的对象是 this这个对象

    private synchronized void sellTickett(){
        if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的   
            //通过sleep方法来模拟出票时间
            Thread.sleep(millis:100);//alt enter 捕获异常
            sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
            tickets --;
        }
    }

同步静态方法就是把synchronized关键字加到静态方法上

  • 格式:修饰符 static synchronized 返回值类型 方法名(方法参数){ }
    image.png
    然后上面那个两种方法的对象应该是一样的 都是方法里的 类名.class 对象
  • 同步静态方法的锁的对象是 类名.class这个对象

线程安全的类

  • StringBuffer
    线程安全,可变的字符序列
    从JDK5开始,被StringBuilder替代,通常应该使用StringBuilder类,因为它支持所有相同的操作,但它更快,因为它不执行同步
  • Vector
    从java2平台v1.2开始,该类改进了List接口,使其成为JavaCollectionFramework的成员。与新的集合实现不同,Vector被同步,如果不需要线程安全的实现,建议使用ArrayList代替Vector
  • Hashtable
    该类实现了一个哈希表,它将键映射到值,任何非null对象都可以用作键或者值
    从java2平台v1.2开始,该类进行了改进,实现了Map接口,使其成为JavaCollectionFramework的成员。与新的集合实现不同,Hashtable被同步。如果不需要线程安全的实现,建议使用HashMap代替Hashtable
StringBuffer sb = new StringBuffer();//加了synchronized关键字,所以也是同步方法,是线程安全的
StringBuilder sb2 = new StringBuilder();//方法没有加synchronized关键字,所以是线程不安全

Vector<String> v = new Vector<String>();//加了synchronized关键字,所以也是同步方法,是线程安全的
ArrayList<String> array = new ArrayList<String>();//方法没有加synchronized关键字,所以是线程不安全

Hashtable<String,String> ht = new Hashtable<String,String>();//加了synchronized关键字,所以也是同步方法,是线程安全的
HashMap<String,String> hm = new HashMap<String,String>();//方法没有加synchronized关键字,所以是线程不安全

//将线程不安全变成线程安全 所有的都是类似的表示
List<String> list = Collections.synchronizedlist(new ArrayList<String>())

Lock锁

image.png

public class SellTicket implements Runnable{
   private int tickets = 100;
   private Lock lock = new Reentrantlock();
   //重写run方法 实现卖票
   @Override
   public void run(){
      while(true){
          lock.lock();
              if(tickets>0){//票数大于0 就卖票 并且告知是哪个窗口卖的 
                   //通过sleep方法来模拟出票时间 
                   Thread.sleep(millis:100);//alt enter 捕获异常
                   sout(Thread.currentThread().getName()+"正在出售第"+tickets+"张票");
                   tickets --;  
              }
              lock.unlock();
       }
   
//主程序SellTicketDemo
//创建SellTicket 对象 
SellTicket st= new SellTicket ();
//创建三个线程类的对象,把SellTicket 对象作为构造方法的参数,并且给出对应的窗口名称
Thread t1 = new Thread (st,name:"窗口1");
Thread t2 = new Thread (st,name:"窗口2");
Thread t3 = new Thread (st,name:"窗口3");
//启动线程
t1.start();
t2.start();
t3.start();

通过lock和unlock加锁和释放锁
一般会用如下表是,用try catch
image.png

评论

暂无评论