黑马程序员——Java基础---多线程<二>

最新推荐文章于 2015-12-07 14:27:34 发布
最新推荐文章于 2015-12-07 14:27:34 发布
阅读量485 收藏
点赞数
分类专栏： 黑马程序 文章标签： 解决方案 多线程 死锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mu_se/article/details/46391481
版权

——- android培训、java培训、期待与您交流！ ——–

7.5、线程安全问题

线程安全 ：一数据错乱、二死锁

问题演示 一：数据错乱
package XianChen;

public class LiZi {

    public static void main(String[] args) {
//      开启新线程  将要运行的 对象传入
        XianCh x = new XianCh();
        Thread t1 = new Thread(x);
        Thread t2 = new Thread(x);
        Thread t3 = new Thread(x);
//      启动新线程
        t1.start();
        t2.start();
        t3.start();

    }
}
class XianCh implements Runnable{
    private int num=100;
//  覆写 抽象方法 run()
    public void run() {

        for(int x=0;x<50;x++){
            if(num>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"……"+ num--);                   
            }
        }   
    }

}
class XianCh2 extends Thread{

//  覆写 抽象方法 run()
    public void run() {
        for(int x=10;x>0;x--)
            System.out.println(Thread.currentThread().getName()+"……"+x);

    }

}
/*
 * 输出结果截取：
    Thread-0……13
    Thread-2……12
    Thread-1……11
    Thread-0……10
    Thread-2……9
    Thread-1……8
    Thread-0……7
    Thread-2……6
    Thread-1……5
    Thread-0……4
    Thread-2……3
    Thread-1……2
    Thread-0……1
    Thread-2……0
    Thread-1……-1        //错误数据

*/
问题分析：

出现上图安全问题的原因在于Thread-0通过了if判断后，在执行到“num–”语句之前，num此时仍等于1。
CPU切换到Thread-1、Thread-2、Thread-3之后，这些线程依然可以通过if判断，从而执行“num–”的操作，因而出现了0、-1的情况。

也就是说线程安全问题产生的原因：

1. 多个线程在操作共享的数据。
2. 操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致线程安全问题的产生。
解决方案

思路：
保证单一线程操作数据

具体方法

synchronized

在java中，用同步代码块就可以解决这个问题。
同步代码块的格式：
synchronized(对象){
       需要被同步的代码;
}

同步的好处：解决了线程的安全问题。
同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。
同步的前提：必须有多个线程并使用同一个锁。
例：

package XianChen;
public class LiZi {

    public static void main(String[] args) {
//      开启新线程  将要运行的 对象传入
        XianCh x = new XianCh();
        Thread t1 = new Thread(x);
        Thread t2 = new Thread(x);
        Thread t3 = new Thread(x);
//      启动新线程
        t1.start();
        t2.start();
        t3.start();

    }
}
class XianCh implements Runnable{
    private int num=100;
//  覆写 抽象方法 run()
// 使用 synchronized 同步函数         方式 一
    public synchronized void run() {

        for(int x=0;x<50;x++){
//          方式二 加入同步代码块
            synchronized(obj ){
                if(num>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }           System.out.println(Thread.currentThread().getName()+"……"+ num--);                   
                }
            }
        }   
    }   
}
class XianCh2 extends Thread{   
//  覆写 抽象方法 run()
    public void run() {
        for(int x=10;x>0;x--)           System.out.println(Thread.currentThread().getName()+"……"+x);    
    }
}

注：
同步函数和同步代码块的区别：
1. 同步函数的锁是固定的this。
2. 同步代码块的锁是任意的对象。
建议使用同步代码块。

由于同步函数的锁是固定的this，同步代码块的锁是任意的对象，那么如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

问题演示 二：死锁
概念、原因、条件

什么叫死锁？
所谓死锁: 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。
那么为什么会产生死锁呢？
1.因为系统资源不足。
2.进程运行推进的顺序不合适。
3.资源分配不当。

产生死锁的条件有四个：
1.互斥条件：所谓互斥就是进程在某一时间内独占资源。
2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3.不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

死锁 一：请求与保持条件
package XianChen;
/**
 * 
 *  
 */
public class LiZi {

    public static void main(String[] args) {
        Rec r = new Rec();
//      开启新线程  将要运行的 对象传入
        Sell s= new Sell(r);
        Get g = new Get(r);
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(g);
//      启动新线程
        t1.start();
        t2.start();
    }
}
class Rec {
    private Object objA=new Object();
    private Object objB=new Object();
    private boolean flag=true;
    private int A=100;
    private int B=100;

    public  void sell() {   
        for(int x=0;x<50;x++){
            synchronized(objA){
                System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 A"+ A--);
                synchronized(objB){
                    if(!flag)
                        System.out.println(Thread.currentThread().getName()+"：B上锁我拿到 B"+ B--);
                }
            }
        }
    }
    public void get(){
        synchronized(objB){
            System.out.println(Thread.currentThread().getName()+"：B上锁我拿到 B"+ B--);
            synchronized(objA){
                if(flag){
                    System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 A"+ A--);
                    flag=false;
                }
            }
        }
    }
}

class Sell implements Runnable{
    private Rec r=null;
    Sell(Rec r){
        this.r = r;
    }
    public void run() {
        while(true){
            r.sell();
        }
    }
}

class Get implements Runnable{
    private Rec r=null;
    Get(Rec r){
        this.r=r;
    }
    public void run() {
        while(true){        
            r.get();
        }       
    }
}
/*
        输出结果：
        Thread-0：A上锁我拿到 A100
        Thread-1：B上锁我拿到 B100
 */
问题分析

死锁大多是因为多线程访问共享资源，由于访问的顺序不当所造成的，通常是一个线程锁定了一个资源A，而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。

解决方案

避免锁的嵌套，用完之后立即解锁

具体案例
package XianChen;
/**
 * 
 *  
 */
public class LiZi {

    public static void main(String[] args) {
        Rec r = new Rec();
//      开启新线程  将要运行的 对象传入
        Sell s= new Sell(r);
        Get g = new Get(r);
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(g);
//      启动新线程
        t1.start();
        t2.start();
    }
}
class Rec {
    private Object objA=new Object();
    private Object objB=new Object();
    private boolean flagA=true,flagB=true;
    private int A=100;
    private int B=100;

    public  void sell() {
    // 当两个资源都为零 时 停止程序
        while(flagA||flagB){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(objA){
                if(A>0)
                    System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 A"+ A--);
                else
                    flagA =false;
            }
            synchronized(objB){
                if(B>0)
                    System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 B"+ B--);
                else
                    flagB =false;
            }           
        }

    }
    public void get(){
        // 当两个资源都为零 时 停止程序
        while(flagA||flagB){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized(objB){
                if(B>0)
                    System.out.println(Thread.currentThread().getName()+"：B上锁我拿到 B"+ B--);
                else
                    flagB =false;
            }
            synchronized(objA){
                if(A>0)
                    System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 A"+ A--);
                else
                    flagA =false;
            }
        }           
    }

}

class Sell implements Runnable{
    private Rec r=null;
    Sell(Rec r){
        this.r = r;
    }
    public void run() {
        r.sell();
    }
}

class Get implements Runnable{
    private Rec r=null;
    Get(Rec r){
        this.r=r;
    }
    public void run() {     
        r.get();    
    }
}
/*
        输出结果：
        Thread-0：A上锁我拿到 A7
        Thread-0：A上锁我拿到 B7
        Thread-1：B上锁我拿到 B6
        Thread-1：A上锁我拿到 A6
        Thread-0：A上锁我拿到 A5
        Thread-0：A上锁我拿到 B5
        Thread-1：B上锁我拿到 B4
        Thread-1：A上锁我拿到 A4
        Thread-0：A上锁我拿到 A3
        Thread-0：A上锁我拿到 B3
        Thread-1：B上锁我拿到 B2
        Thread-1：A上锁我拿到 A2
        Thread-0：A上锁我拿到 A1
        Thread-0：A上锁我拿到 B1
 */
死锁 二 循环等待条件
问题演示：
package XianChen;
/**
 * 
 *  
 */
public class LiZi {

    public static void main(String[] args) {
        Rec r = new Rec();
//      开启新线程  将要运行的 对象传入
        Sell s= new Sell(r);
        Get g = new Get(r);
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(g);
//      启动新线程
        t1.start();
        t2.start();
    }
}
class Rec {
    private Object objA=new Object();
    private Object objB=new Object();
//  private boolean flagA=true,flagB=true;*/
    private int A=100;
    private int B=100;

    public  void sell() {
        synchronized(objA){
            if(A>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 A"+ A--);              
            }
            get();
        }       

    }
    public synchronized void get(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(objA){
            if(B>0){
                System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 B"+ B--);
            }
        }
    }           

}

class Sell implements Runnable{
    private Rec r=null;
    Sell(Rec r){
        this.r = r;
    }
    public void run() {
        while(true){
            r.sell();               
        }
    }
}

class Get implements Runnable{
    private Rec r=null;
    Get(Rec r){
        this.r=r;
    }
    public void run() { 
        while(true){
            r.get();                
        }

    }
}
/*
 */
问题分析

这其实还是两个锁的嵌套
执行get 方法则必须获取this对象锁，然后才能执行其中的同步代码块。
当线程t1获取到objA对象锁执行同步代码块，线程t2获取到this对象锁执行get方法。同步代码块中的get方法因无法获取到this对象锁无法执行，sell方法中的同步代码块因无法获取到objA对象锁无法执行，就会产生死锁。

解决方案

同问题一，去掉锁的嵌套

具体方案
package XianChen;
/**
 * 
 *  
 */
public class LiZi {

    public static void main(String[] args) {
        Rec r = new Rec();
//      开启新线程  将要运行的 对象传入
        Sell s= new Sell(r);
        Get g = new Get(r);
        Thread t1 = new Thread(s);
        Thread t2 = new Thread(g);
//      启动新线程
        t1.start();
        t2.start();
    }
}
class Rec {
    private Object objA=new Object();
    private Object objB=new Object();
//  private boolean flagA=true,flagB=true;*/
    private int A=100;
    private int B=100;

    public  void sell() {
        synchronized(objA){
            if(A>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 A"+ A--);              
            }
            get();
        }       

    }
    public void get(){
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized(objA){
            if(B>0){
                System.out.println(Thread.currentThread().getName()+"：A上锁我拿到 B"+ B--);
            }
        }
    }           

}

class Sell implements Runnable{
    private Rec r=null;
    Sell(Rec r){
        this.r = r;
    }
    public void run() {
        while(true){
            r.sell();               
        }
    }
}

class Get implements Runnable{
    private Rec r=null;
    Get(Rec r){
        this.r=r;
    }
    public void run() { 
        while(true){
            r.get();                
        }

    }
}
/*
        输出结果：
        Thread-0：A上锁我拿到 B89
        Thread-1：A上锁我拿到 B88
        Thread-0：A上锁我拿到 A89
        Thread-0：A上锁我拿到 B87
        Thread-0：A上锁我拿到 A88
        Thread-0：A上锁我拿到 B86
        Thread-0：A上锁我拿到 A87
        Thread-0：A上锁我拿到 B85
        Thread-0：A上锁我拿到 A86
        Thread-0：A上锁我拿到 B84
        Thread-0：A上锁我拿到 A85
        Thread-0：A上锁我拿到 B83
        Thread-0：A上锁我拿到 A84
        Thread-0：A上锁我拿到 B82
        Thread-1：A上锁我拿到 B81
 */
死锁处理总结

不难看出，产生死锁主要是四个条件，因此只要不让四个发生即可

互斥：
要打破这个条件，就是要让多个线程能共享资源，就相当于A和B能同时举起ball1一样，当然在这个例子里我们可以这样修改规则，但是在其它程序中就不一定能了，比如说一个“读”线程，一个“写”线程，它们都能操作同一文件。在这种情况下，我们就不能“又读又写”文件，否则有可能会读到脏数据！因此我们很少从这方面考虑。

占有等待
打破占有等待，只要当检测到自己所需的资源仍被别的线程占用，即释放自己已占有的资源（毫不利己，专门利人，呵呵~），或者在经过一段时间的等待后，还未得到所需资源，才释放，这都能打破占有等待。

不剥夺，循环等待
这两个线程也是如此，经过一段时间的等待后，还未得到所需资源，
就释放资源，即可打破占有等待；
另外其实打破非剥夺，只要给线程制定一个优先级即可

——– android培训、java培训、期待与您交流！ ———

mu_se
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda...Java基础小节练习题答案
黑马程序员——java基础---多线程(二)
Sa916487698的博客
07-15 108
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 　　 线程间的通信：简单来说，就是多个线程在操作同一资源，但操作的动作不同。 　　试想一下，对于同一个资源做不同的操作，这势必会在操作的过程中产生矛盾。为了避免这种情况的发生，就需要用的synchronized来保证，每次对共享资源的操作，只能是一条线程在进行。在用到同步的时候，...
黑马程序员——Java基础---多线程同步
qq_14926317的博客
12-07 364
理解同步多线程使得多个任务可以并行执行，提高了工作效率。但同时产生了一个问题，因为线程间过快的切换，对资源的同时访问产生拥堵。就好像，大家都要进一个小巷里去，但小巷只容一人通过，结果第一个人刚要进去，第二个人也进去，两个人就挤在了一起，堵住了，出错了。实现要实现线程同步有两种方法： 关键字sunchronized 同步锁Lock 两种方法的使用方式基本相同，具体实现如下。同步关键字：synchron
黑马程序员——JAVA基础----多线程（二）
Du_jing的博客
11-05 354
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 多线程（二） 01_多线程(单例设计模式) 单例设计模式：保证类在内存中只有一个对象。 如何保证类在内存中只有一个对象呢？ (1)控制类的创建，不让其他类来创建本类的对象。private (2)在本类中定义一个本类的对象。Singl
黑马程序员——Java基础---多线程详解
Smile_Dark的博客
07-06 641
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------  一，多线程概念          要掌握多线程，首先你需要了解进程和线程的概念，以及两者之间的关系。          1，进程          进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系
黑马程序员–Java多线程讲解笔记
12-22
当一个进程中线程有多个时，是多线程。 　为什么要用多线程 　1，让计算机"同时"做多件事情，节约时间。 　2，后台运行程序，提高程序的运行效率.。 　3，多线程可以让程序"同时"处理多个事情。 　4，...
第-章-JAVA多线程优秀文档.pptx
12-01
第-章-JAVA多线程优秀文档.pptx
Java基础[06-多线程].ppt
12-09
Java线程具有五中基本状态 新建状态（New）：当线程对象对创建后，即进入了新建状态，如：Thread t = new MyThread(); 就绪状态（Runnable）：当调用线程对象的start()方法（t.start();），线程即进入就绪状态。...
大学课程讲义-Java基础-多线程.pptx
最新发布
08-14
大学课程讲义_Java基础_多线程.pptx
黑马程序员——Java基础---初识
mu_se的博客
06-02 624
——- android培训、java培训、期待与您交流！ ———-待编……
黑马程序员——Java基础---语法<三>
mu_se的博客
06-02 583
——– android培训、java培训、期待与您交流！ ———-基本语句 1条件语句1if语句 2switch语句 3循环语句 2函 数1java中的函数的定义格式 2如何定义一个函数 3数组与字符串 1数组 2字符串基本语句If 、switch 、do while 、 while、 for、 增强for、 迭代器 iterator1、条件语句：条件语句有两种：if语句和switch语句
黑马程序员——Java基础---深层拷贝(数组、ArrayList)
mu_se的博客
06-06 561
——- android培训、java培训、期待与您交流！ ———-JAVA中复制数组元素值：（深拷贝）在JAVA里面，可以用复制语句“A=B”给基本类型的数据传递值，但是如果A,B是两个同类型的数组，复制就相当于将一个数组变量的引用传递给另一个数组；如果一个数组发生改变，那么引用同一数组的变量也要发生改变。 public static void main(String[] args) {
黑马程序员——Java基础---IO流<实例>
mu_se的博客
06-08 532
——- android培训、java培训、期待与您交流！ ———-概述流用于处理设备上数据。 流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。 流也进行分类： 1：按照数据流的方向不同可以分为：输入流和输出流。 2：按照处理数据单位不同可以分为：字节流和字符流。 3：按照实现功能不同可以分为：节点流和处理流。 这里继续上次的内容
黑马程序员——Java基础---多线程<一>
mu_se的博客
06-06 514
——- android培训、java培训、期待与您交流！ ———7、多线程7.1 概念一个程序同时执行多个任务。通常，每一个任务称为一个线程（thread），它是线程控制的简称。可以同时运行一个以上线程的程序称为：多线程程序（multithreaded）。多进程与多线程有哪些区别呢？ 本质的区别在于每个进程拥有自己的一整套变量，而线程则共享数据。进程：正在进行中的程序（直译）。 线程：进程中一个
黑马程序员——Java基础---网络编程&正则
mu_se的博客
06-09 506
——- android培训、java培训、期待与您交流！ ———- 网络编程的简单涉及 正则的概述加 常用表达式
黑马程序员——Java基础---语法<二>
mu_se的博客
06-02 473
——– android培训、java培训、期待与您交流！ ———-运算符 总览 1位运算符1与运算符 2或运算符 3非运算符 4异或运算符 2算术运算符1普通算术运算符 2递归类算术运算符 3移位运算符 4关系运算符 5逻辑运算符 6条件运算符 7赋值运算符 8其他1字符串运算符 2转型运算符 3括号运算符运算符总览Java 中运算符指明对操作数的运算方式。组成表达式的Java操作符有很多种
黑马程序员——Java基础---面向对象<一>
mu_se的博客
06-05 462
—— android培训、java培训、期待与您交流！ ———-面向对象1.1、概念面向对象是相对面向过程而言，面向对象和面向过程都是一种思想 面向过程：（强调功能行为）强调的是功能行为。代表语言：C语言。 面向对象：（强调对象） 将功能封装进对象，强调具备了功能的对象。代表语言：Java、C++、C#。 1.2、优点1：将复杂的事情简单化。 2：面向对象将以前的过程中的执行者，变成了指挥者。 3
黑马程序员——Java基础---单例模式
mu_se的博客
06-07 453
——- android培训、java培训、期待与您交流！ ——–多线程中 有两种单利模式： * 饿汉式 * 懒汉式1、概念、种类、特点概念 java中单例模式是一种常见的设计模式，单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。 种类 单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。 特点： 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <!-- 防止将依赖传递到其他模块中 --> <optional>true</optional> <!-- 只在运行时起作用，打包时不打进去（防止线上执行打包后的程序，启动文件监听线程
06-09
其中，`<optional>true</optional>`表示这个依赖是可选的，不会被传递到其他模块中，只在运行时起作用，打包时不会打进去，这样可以防止线上执行打包后的程序，启动文件监听线程。 一旦添加了`spring-boot-devtools...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值