比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

java中线程安全,线程死锁,线程通信快速入门

java中线程安全,线程死锁,线程通信快速入门

一:多线程安全问题

###1 引入

复制代码
    /*
     * 多线程并发访问同一个数据资源
     * 3个线程,对一个票资源,出售
     */
    public class ThreadDemo {
     public static void main(String[] args) {
       //创建Runnable接口实现类对象
       Tickets t = new Tickets();
       //创建3个Thread类对象,传递Runnable接口实现类
       Thread t0 = new Thread(t);
       Thread t1 = new Thread(t);
       Thread t2 = new Thread(t);
       
       t0.start();
       t1.start();
       t2.start();
       
     }
    }

    /*
     *  通过线程休眠,出现安全问题
     */
    public class Tickets implements Runnable{
     
     //定义出售的票源
     private int ticket = 100;
     private Object obj = new Object();
     
     public void run(){
       while(true){
 
         //对票数判断,大于0,可以出售,变量--操作
           if( ticket > 0){
             try{
                Thread.sleep(50); //加了休眠让其他线程有执行机会
             }catch(Exception ex){}
             System.out.println(Thread.currentThread().getName()+" 出售第 "+ticket--);
           }
       }
     }
    }
复制代码

 

运行结果出现了这么一种情况:

可见票数为0和-1时都进行了售卖,由此可见多线程操作共享数据存在安全隐患

具体的讲:该处有三个线程t0,t1,t2同时对tickets进行操作,程序一运行,3个线程抢占CPU资源,运行执行过if(tickets>0)接着执行休眠操作,在这短短50ms的够CPU干很多事了,继续卖票。到最后休眠时间结束,线程无需在进行判断tickets是否大于0,便接着往下执行,就导致了安全问题

 ###2:解决办法

###2.1java中提供了同步机制,能够解决线程的安全性问题。

复制代码
    //同步代码块,  同步代码块的锁对象可以是任意的对象
         synchronized (锁对象){
            可能产生线程安全问题的代码
            }
          

    //同步方法, 同步方法中的锁对象是 this
        public synchronized void method()
              可能产生线程安全问题的代码
        }
           
    //静态同步方法,静态同步方法中的锁对象是 类名.class
        public synchronized void method()
                      可能产生线程安全问题的代码
        }
复制代码

###2.2同步方法(推荐)或同步代码块解决该售票例子的线程安全问题

复制代码
public class Tickets implements Runnable {

    // 共一百票
    int tickets = 20;
    Object obj = new Object();

    @Override
    public void run() {
        // 模拟卖票
        while (true) {
            method();
        }
    }

    public synchronized void method() {
        if (tickets > 0) {
            // 线程休眠模拟安全问题
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖票:" + tickets--);
        }
    }

}
复制代码

###2.3同步代码块的原理

同步操作给对象上了一把对象锁(对象监视器),没有锁的线程不能够继续往下执行,只能等。
线程遇到同步代码块后,线程判断是否有同步锁,有则获取锁,进入同步中去执行,执行完毕释放锁。没有则不能够进行同步代码块中
由于加了同步后,线程进同步判断锁,获取锁,执行完毕释放锁,导致程序的运行速度下降。

举个上厕所的例子:假设有一片区域只有一个厕所且只有一个坑位(共享数据),有三人A,B,C(三线程)需要上厕所,A拿着钥匙先进去上小厕,需要开门,这个门就相当于对象锁,你进来就得先开门并关上,小厕上了一分钟(Thread.sleep),上完出来给钥匙给B(释放锁),B在拿着钥匙去开门上大厕,时间十分钟。。这时候C就只能在门外干急着了等B上完了

##3:Lock锁对synchronized的改进

使用同步方法有个缺点:当在sleep休眠时若发生了异常,则该线程是出不了同步的,锁对象释放不了。

因此,SUN公司在jdk5后提供了个Lock接口,Lock接口中的常用方法

void lock()
void unlock()

复制代码
public class Tickets implements Runnable {

    // 共一百票
    int tickets = 20;
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        // 模拟卖票
        while (true) {
            //调用lock方法加锁
            lock.lock();
            if (tickets > 0) {
                // 线程休眠模拟安全问题
                try {
                    Thread.sleep(50);
                    System.out.println(Thread.currentThread().getName()+" 出售第"+tickets--);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

}
复制代码

 

二:线程的死锁

 同步锁使用的弊端:当线程任务中出现了多个同步(多个锁)时,如果同步中嵌套了其他的同步。这时容易引发一种现象:程序出现无限等待,这种现象我们称为死锁。这种情况能避免就避免掉

synchronzied(A锁){
    synchronized(B锁){
         
  }
}

死锁的一个形象比喻:两个人打架互相揪着对方头发不放,A说你先放,B说你先放,两人都不肯先放,就造成了死锁.

 下面为产生死锁的一个例子

 

复制代码
public class lockA {
    //保证对象的唯一性
    private lockA(){
        
    }
    public final static lockA locka = new lockA();
}


public class LockB {
    //保证对象的唯一性
    private LockB() {
        
    }
    public static final LockB lockb = new LockB();
}


public class DeadLock implements Runnable {

    private int i = 0;

    @Override
    public void run() {
        while (true) {
            if (i % 2 == 0) {
                // 先进入A同步,在进入B同步
                synchronized (lockA.locka) {
                    System.out.println("if---locka");
                    synchronized(LockB.lockb){
                        System.out.println("if---lockb");
                    }
                }
            } else {
                //先进入B同步在进入A同步
                synchronized (LockB.lockb) {
                    System.out.println("else---lockb");
                    synchronized(lockA.locka){
                        System.out.println("else---locka");
                    }
                }
            }
            i++;
        }

    }

}


public class DeadLockDemo {
    public static void main(String[] args) {
        DeadLock deadLock = new DeadLock();
        Thread t0 = new Thread(deadLock);
        Thread t1 = new Thread(deadLock);
        t0.start();t1.start();
    }
}
复制代码

 

 

 三:线程通信

线程之间的通信:多个线程在处理同一个资源,但是处理的动作(线程的任务)却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制

打个比喻:就好像平时收快递一样,快递先由卖家包装,联系收件人员收发货,快递一路经过各个地点中转在到达你的手里。把这一系列过程看作一个个线程,所有线程共同合作处理你这个包裹,从而达到有效利用资源。

等待唤醒机制所涉及到的方法:

wait() :等待,将正在执行的线程释放其执行资格 和 执行权,并存储到线程池中。
notify():唤醒,唤醒线程池中被wait()的线程,一次唤醒一个,而且是任意的。
notifyAll(): 唤醒全部:可以将线程池中的所有wait() 线程都唤醒。

其实,所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是,这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁,这样才可以明确出这些方法操作的到底是哪个锁上的线程。

仔细查看JavaAPI之后,发现这些方法 并不定义在 Thread中,也没定义在Runnable接口中,却被定义在了Object类中,为什么这些操作线程的方法定义在Object类中?

因为这些方法在使用时,必须要标明所属的锁,而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。

Java实现代码如下:

复制代码
A 线程等待与唤醒案例的实现

     /*
      *  定义资源类,有2个成员变量
      *  name,sex
      *  同时有2个线程,对资源中的变量操作
      *  1个对name,age赋值
      *  2个对name,age做变量的输出打印
      */
     public class Resource {
      public String name;
      public String sex;
      public boolean flag = false;
     }

     /*
      *  输入的线程,对资源对象Resource中成员变量赋值
      *  一次赋值 张三,男
      *  下一次赋值 lisi,nv
      */
     public class Input implements Runnable {
      private Resource r ;
      
      public Input(Resource r){
        this.r = r;
      }
      
      public void run() {
        int i = 0 ;
        while(true){
          synchronized(r){
            //标记是true,等待
              if(r.flag){
                try{r.wait();}catch(Exception ex){}
              }
            
            if(i%2==0){
              r.name = "张三";
              r.sex = "男";
            }else{
              r.name = "lisi";
              r.sex = "nv";
            }
            //将对方线程唤醒,标记改为true
            r.flag = true;
            r.notify();
          }
          i++;
        }
      }

     }
     
     /*
      *  输出线程,对资源对象Resource中成员变量,输出值
      */
     public class Output implements Runnable {
      private Resource r ;
      
      public Output(Resource r){
        this.r = r;
      }
      public void run() {
        while(true){
          synchronized(r){  
            //判断标记,是false,等待
          if(!r.flag){
            try{r.wait();}catch(Exception ex){}
            }
          System.out.println(r.name+".."+r.sex);
          //标记改成false,唤醒对方线程
          r.flag = false;
          r.notify();
          }
        }
      }

     }

     /*
      *  开启输入线程和输出线程,实现赋值和打印值
      */
     public class ThreadDemo{
      public static void main(String[] args) {
        
        Resource r = new Resource();
        
        Input in = new Input(r);
        Output out = new Output(r);
        
        Thread tin = new Thread(in);
        Thread tout = new Thread(out);
        
        tin.start();
        tout.start();
      }
     }
复制代码

输出结果如下:(完成了协同工作,赋值完后输出,输出完后赋值的目的)

原文地址 https://www.cnblogs.com/zengcongcong/p/11318686.html

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS