java——多线程讲解二

多线程是多个线程同时对同一个数据执行相同或不同的任务。要注意的是，这样的操作很大可能会出现线程安全问题，和线程死锁问题。
现介绍一下为什么要用同步线程：

public class MyThread implements Runnable {
    private int ticket=10;
    @Override
    public void run() {
       for(int i=0;i<10;i++){
           if(this.ticket>0){
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                e.printStackTrace();
             }     
             System.out.println(Thread.currentThread().getName()+"正在出售倒数第："+this.ticket--+"张票");
           }
       }
    }
}
单多个线程访问同一个对象是，会出现其中一条线程执行业务代码的时候，CPU的执行权被另一条线程抢走了，通过上面代码可以明显看出输出了负数，这和我们现实生活是完全不存在的。这就是线程安全问题

这使得我们需要通过静态化ticket，或者是用同步线程来实现我们要的功能。

下面先介绍一下怎么解决线程安全问题的实现；
方式一：可以使用同步代码块来实现。
示例：

public class MyThread implements Runnable {
    private int ticket=10;
    @Override
    public synchronized void run() {
       for(int i=0;i<10;i++){
           if(this.ticket>0){
             try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }      
             System.out.println(Thread.currentThread().getName()+"正在出售倒数第："+this.ticket--+"张票");
           }
       }
    }
}

示例二：使用同步代码块来实现

public class MyThread implements Runnable {
    private int ticket=10;
    @Override
    public void run() {
       for(int i=0;i<10;i++){
            synchronized ("锁"){
                  if(this.ticket>0){
             try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }      
                 System.out.println(Thread.currentThread().getName()+"正在出售倒数第："+this.ticket--+"张票");
           }
       }
          }
           
    }
}

上面两种方式都能实现代码的同步，
线程之所以能同步，是因为加了一个锁对象，在使用同步函数的时候，锁对象是对象本身this，而在使用同步代码块的时候，锁对象是自己定义的，可以是任何对象。
建议：要是用同步线程的时候，建议优先使用同步代码块，因为同步代码块锁对象是自己定义的，方便对锁进行操作。这个原因下面将要说到。

通过上面的代码会发现，我在方法中使用了sleep方法。sleep（）方法是Thread类中的一个方法，为什么没有把它放到上一节将，是因为这个方法有点特殊。这个涉及到线程的各种状态：
线程开始的时候是创建状态：（new 对象的时候.）
当调用了start方法的时候，线程处于可以运行状态，在这个状态下的线程具备CPU的等待权，但是不具备CPU的执行权。
当线程执行的时候他具备了CPU的执行权。这个时候称为运行状态。
当完成任务代码块的时候，线程死亡。
在可运行状态和运行状态之间还有一个状态，这个状态称为临时阻塞状态。进入这个状态需要调用sleep()或wait()方法。这个时候线程不具备CPU的等待资格，和CPU的执行权。
sleep()方法是自己设置阻塞时间。当时间一到，线程会自动转换成可运行状态。他是Thread中的一个方法。当一个线程在同步方法中调用了sleep方法，其它线程不能调用它的其它同步方法。
swit()是Object中的一个方法，当线程调用了这个方法。需要通过notify或者notifyAll方法来唤醒线程。线程阻塞是存放在线程池中的。一个对象对应一个线程池。
当线程阻塞是，线程会自动释放CPU的等待权和CPU的执行权。但是如果使用的sleep方法，线程是不会释放锁对象的。而wait方法是会释放锁对象。
下面说下经典的线程通讯：

//产品类
class Product{
    
    String name;  //名字
    
    double price;  //价格
    
    boolean flag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。
    
}

//生产者
class Producer extends Thread{
    
    Product  p ;    //产品
    
    public Producer(Product p) {
        this.p  = p ;
    }
    
    
    
    @Override
    public void run() {
        int i = 0 ; 
        while(true){
         synchronized (p) {
            if(p.flag==false){
                 if(i%2==0){
                     p.name = "苹果";
                     p.price = 6.5;
                 }else{
                     p.name="香蕉";
                     p.price = 2.0;
                 }
                 System.out.println("生产者生产出了："+ p.name+" 价格是："+ p.price);
                 p.flag = true;
                 i++;
                 p.notifyAll(); //唤醒消费者去消费
            }else{
                //已经生产 完毕，等待消费者先去消费
                try {
                    p.wait();   //生产者等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
             
        }   
      } 
    }
}


//消费者
class Customer extends Thread{
    
    Product p; 
    
    public  Customer(Product p) {
        this.p = p;
    }
    
    
    @Override
    public void run() {
        while(true){
            synchronized (p) {  
                if(p.flag==true){  //产品已经生产完毕
                    System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
                    p.flag = false; 
                    p.notifyAll(); // 唤醒生产者去生产
                }else{
                    //产品还没有生产,应该 等待生产者先生产。
                    try {
                        p.wait(); //消费者也等待了...
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }   
    }
}

public class Demo5 {
    
    public static void main(String[] args) {
        Product p = new Product();  //产品
        //创建生产对象
        Producer producer = new Producer(p);
        //创建消费者
        Customer customer = new Customer(p);
        //调用start方法开启线程
        producer.start();
        customer.start();
        
        
    }
    
}

线程死锁的体现：

lass DeadLock extends Thread{
    
    public DeadLock(String name){
        super(name);
    }
    
    
    public void run() {
        if("张三".equals(Thread.currentThread().getName())){
            synchronized ("遥控器") {
                System.out.println("张三拿到了遥控器，准备 去拿电池!!");
                synchronized ("电池") {
                    System.out.println("张三拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
                }
            }
        }else if("狗娃".equals(Thread.currentThread().getName())){
            synchronized ("电池") { 
                System.out.println("狗娃拿到了电池，准备去拿遥控器!!");
                synchronized ("遥控器") {
                    System.out.println("狗娃拿到了遥控器与电池了，开着空调爽歪歪的吹着...");
                }
            }
            
        }   
    }
    
    
}

public class Demo2 {

    public static void main(String[] args) {
        DeadLock thread1 = new DeadLock("张三");
        DeadLock thread2 = new DeadLock("狗娃");
        //开启线程
        thread1.start();
        thread2.start();
        
        
    }
    
}

死锁现象出现 的根本原因：

1. 存在两个或者两个以上的线程。
2. 存在两个或者两个以上的共享资源。

【注】讲解可能有不足的地方，希望各位小伙伴能帮我补充不足之处，谢谢！
复制得来终觉浅，要想知道自己敲！