Java多线程和死锁

一 、多线程:

售票窗口简单实例:

public class SaleTicket {

    public static class Sale implements Runnable{
        private int ticket=10;
//        @Override
//        public void run() {
//            while(true){
//                synchronized(this){         //同步代码块   synchronized(this)锁着的是对象 
//                    if(ticket>0){
//                        try {
//                            Thread.sleep(500);
//                        } catch (InterruptedException e) {
//                            // TODO Auto-generated catch block
//                            e.printStackTrace();
//                        }
//                        System.out.println(Thread.currentThread().getName()+"卖完一张,车票剩余:"+ticket--);
//                    }else break;
//                }
//            }
//            
//        }

        @Override
        public void run() {
            for(int i=0;i<20;i++){
                tell();
            }
        }
        
        public synchronized void tell(){    //同步方法
            if(ticket>0){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖完一张,车票剩余:"+ticket--);
            }
        }
        
    }
    public static void main(String[] args) {
        Sale s = new Sale();
        Thread t1 = new Thread(s, "售票员1");
        Thread t2 = new Thread(s, "售票员2");
        Thread t3 = new Thread(s, "售票员3");
        t1.start();
        t2.start();
        t3.start();
    }

}

运用结果:

售票员1卖完一张,车票剩余:10
售票员1卖完一张,车票剩余:9
售票员1卖完一张,车票剩余:8
售票员1卖完一张,车票剩余:7
售票员3卖完一张,车票剩余:6
售票员1卖完一张,车票剩余:5
售票员2卖完一张,车票剩余:4
售票员2卖完一张,车票剩余:3
售票员3卖完一张,车票剩余:2
售票员3卖完一张,车票剩余:1

 

二、线程死锁:

线程的同步化可能会造成死锁,死锁发生在两个线程相互持有对方正在等待的东西(实际是两个线程共享的东西)。只要有两个线程和两个对象就可能产生死锁

 

/** 
*  
* 一个简单的死锁类 
* 当DeadLock类的对象flag==1时(td1),先锁定o1,睡眠500毫秒 
* 而td1在睡眠的时候另一个flag==0的对象(td2)线程启动,先锁定o2,睡眠500毫秒 
* td1睡眠结束后需要锁定o2才能继续执行,而此时o2已被td2锁定; 
* td2睡眠结束后需要锁定o1才能继续执行,而此时o1已被td1锁定; 
* td1、td2相互等待,都需要得到对方锁定的资源才能继续执行,从而死锁。 
*/ 
public class DeadLock implements Runnable{
    public int flag = 1;
    //静态对象是类的所有对象共享的  
    private static Object o1 = new Object(),o2 = new Object();
    
    @Override
    public void run() {
        System.out.println("flag=" + flag);  
        if(flag == 1){
            synchronized (o1) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                synchronized(o2){
                    System.out.println("1");
                }
            }
            
        }
        
        if(flag == 0){
            synchronized(o2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
                synchronized(o1){
                    System.out.println("0");
                }
            }
            
        }
    }

    public static void main(String[] args) {
        DeadLock td1 = new DeadLock();
        DeadLock td2 = new DeadLock();
        td1.flag = 1;
        td2.flag = 0;
        new Thread(td1,"td1").start();
        new Thread(td2,"td2").start();
    }

    
}

 

运行结果:

flag=1
flag=0

结果产生了死锁

 

    原文作者:flyingfish!
    原文地址: https://www.cnblogs.com/gongjian/p/6121447.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞