JAVA提高篇（34）-- Java多线程的同步与死锁

来源：互联网发布：视频同声翻译软件编辑：程序博客网时间：2024/06/12 19:48

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

知识要点：

了解线程同步的作用

了解同步代码块以及同步方法的使用

了解死锁的产生

在多线程开发中，同步与死锁是至关重要的需要掌握以下几点：

1、哪里需要同步

2、如何实现同步

3、以及实现同步之后会有哪些副作用。

问题的引出

以卖火车票为例，不管在哪个地方买火车票，最终一趟列车的车票数量是固定的，如果将多个售票点理解为线程的话，则所有线程应该共同拥有同一份票数。

[java] view plain copy
class MyThread implements Runnable{  
    private int ticket = 5 ;    // 假设一共有5张票  
    public void run(){  
        for(int i=0;i<100;i++){  
            if(ticket>0){    // 还有票  
                try{  
                    Thread.sleep(300) ; // 加入延迟  
                }catch(InterruptedException e){  
                    e.printStackTrace() ;  
                }  
                System.out.println("卖票：ticket = " + ticket-- );  
            }  
        }  
    }  
};  
public class SyncDemo01{  
    public static void main(String args[]){  
        MyThread mt = new MyThread() ;  // 定义线程对象  
        Thread t1 = new Thread(mt) ;    // 定义Thread对象  
        Thread t2 = new Thread(mt) ;    // 定义Thread对象  
        Thread t3 = new Thread(mt) ;    // 定义Thread对象  
        t1.start() ;  
        t2.start() ;  
        t3.start() ;  
    }  
};  

从程序的执行结果看，卖出的票数成了负数，程序代码出了问题。

程序的问题：

从运行的结果可以发现，程序中加入了延迟操作，所以在运行的最后出现了负数的情况，那么为什么会出现这种情况呢？

从上面的操作代码可以发现对于票数的操作步骤如下：

1、判断票数是否大于0，大于0则表示还有票可以卖。

2、如果票数大于0，则卖票出去。

但是，在上面的操作代码中，第1步和第2步之间加入了延迟操作，那么一个线程就有可能在还没有对票数进行减操作之前其他线程就已经将票数减少了，这样一来就会出现票数为负的情况。

问题的解决：

如果想解决这样的问题就必须使用同步，所谓的同步就是指多个操作在同一个时间段内只能有一个线程执行，其他线程要等待此线程完成之后才能继续执行。

使用同步问题

想解决资源共享的同步操作问题，可以使用同步代码块和同步方法两种方式完成。

已知代码块分为四种：

普通代码块：是直接定义在方法之中的。

构造块：是直接定义在类中的，优先于构造方法执行，重复调用。

静态块：是使用static关键字声明的，优先于构造块执行，只执行一次。

同步代码块：使用synchronized关键字声明的代码块，称为同步代码块。

同步代码块：

在代码块上加上"synchronized"关键字的话，则此代码块就称为同步代码块。

同步代码块格式：

synchronized(同步对象){

需要同步的代码

}

同步的时候必须指明同步的对象，一般情况下会将当前对象作为同步对象，使用this表示。

[java] view plain copy
class MyThread implements Runnable{  
    private int ticket = 5 ;    // 假设一共有5张票  
    public void run(){  
        for(int i=0;i<100;i++){  
            synchronized(this){ // 要对当前对象进行同步  
                if(ticket>0){    // 还有票  
                    try{  
                        Thread.sleep(300) ; // 加入延迟  
                    }catch(InterruptedException e){  
                        e.printStackTrace() ;  
                    }  
                    System.out.println("卖票：ticket = " + ticket-- );  
                }  
            }  
        }  
    }  
};  
public class SyncDemo02{  
    public static void main(String args[]){  
        MyThread mt = new MyThread() ;  // 定义线程对象  
        Thread t1 = new Thread(mt) ;    // 定义Thread对象  
        Thread t2 = new Thread(mt) ;    // 定义Thread对象  
        Thread t3 = new Thread(mt) ;    // 定义Thread对象  
        t1.start() ;  
        t2.start() ;  
        t3.start() ;  
    }  
};  

从运行的结果可以发现，加入了同步操作，所以不会产生负数的情况，但是程序的执行效率明显降低很多。

同步方法：

除了可以将需要的代码设置成同步代码块之外，也可以使用synchronized关键字将一个方法声明成同步方法。

同步方法定义格式：

synchronized 方法返回值方法名称(参数列表){ }

具体代码如下：

[java] view plain copy
class MyThread implements Runnable{  
    private int ticket = 5 ;    // 假设一共有5张票  
    public void run(){  
        for(int i=0;i<100;i++){  
            this.sale() ;   // 调用同步方法  
        }  
    }  
    public synchronized void sale(){    // 声明同步方法  
        if(ticket>0){    // 还有票  
            try{  
                Thread.sleep(300) ; // 加入延迟  
            }catch(InterruptedException e){  
                e.printStackTrace() ;  
            }  
            System.out.println("卖票：ticket = " + ticket-- );  
        }  
  
    }  
};  
public class SyncDemo03{  
    public static void main(String args[]){  
        MyThread mt = new MyThread() ;  // 定义线程对象  
        Thread t1 = new Thread(mt) ;    // 定义Thread对象  
        Thread t2 = new Thread(mt) ;    // 定义Thread对象  
        Thread t3 = new Thread(mt) ;    // 定义Thread对象  
        t1.start() ;  
        t2.start() ;  
        t3.start() ;  
    }  
};  

所谓的同步就是同样的操作在同一时间段内只能由一个线程进行访问。同步通常用于多个线程同时共享同一资源时。

过多的同步会导致线程死锁。

具体代码如下所示：

[java] view plain copy
class Zhangsan{ // 定义张三类  
    public void say(){  
        System.out.println("张三对李四说：“你给我画，我就把书给你。”") ;  
    }  
    public void get(){  
        System.out.println("张三得到画了。") ;  
    }  
};  
class Lisi{ // 定义李四类  
    public void say(){  
        System.out.println("李四对张三说：“你给我书，我就把画给你”") ;  
    }  
    public void get(){  
        System.out.println("李四得到书了。") ;  
    }  
};  
public class ThreadDeadLock implements Runnable{  
    private static Zhangsan zs = new Zhangsan() ;       // 实例化static型对象  
    private static Lisi ls = new Lisi() ;       // 实例化static型对象  
    private boolean flag = false ;  // 声明标志位，判断那个先说话  
    public void run(){  // 覆写run()方法  
        if(flag){  
            synchronized(zs){   // 同步张三  
                zs.say() ;  
                try{  
                    Thread.sleep(500) ;  
                }catch(InterruptedException e){  
                    e.printStackTrace() ;  
                }  
                synchronized(ls){  
                    zs.get() ;  
                }  
            }  
        }else{  
            synchronized(ls){  
                ls.say() ;  
                try{  
                    Thread.sleep(500) ;  
                }catch(InterruptedException e){  
                    e.printStackTrace() ;  
                }  
                synchronized(zs){  
                    ls.get() ;  
                }  
            }  
        }  
    }  
    public static void main(String args[]){  
        ThreadDeadLock t1 = new ThreadDeadLock() ;      // 控制张三  
        ThreadDeadLock t2 = new ThreadDeadLock() ;      // 控制李四  
        t1.flag = true ;  
        t2.flag = false ;  
        Thread thA = new Thread(t1) ;  
        Thread thB = new Thread(t2) ;  
        thA.start() ;  
        thB.start() ;  
    }  
};  

可以发现线程会因为相互等待而造成死锁。

阅读全文

0 0