线程同步与死锁

1，非同步

下面的卖票过程因为没有做同步处理。最后的结果即使判断>0,但也是会出现-1，原因在sleep（200）等待时，多个线程完成判断，进行资源处理，也就是ticket--时，进行了多次导致出现负数。

（sleep的原因是为了更好的体现效果）

class Mythread11 implements Runnable {
    private int ticket = 10;

    @Override
    public void run() {
        while (true) {
            if (this.ticket > 0) {
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "卖票，ticket="+this.ticket--);
            } else {
                System.out.println("*****票已经卖光了****");
                break;
            }
        }
    }
}

public class ThreadUnLock {
    public static void main(String[] args){
        Mythread11 mythread11 = new Mythread11();
        new Thread(mythread11,"A").start();
        new Thread(mythread11,"B").start();
        new Thread(mythread11,"C").start();
    }
}

可能会出现的结果：

A卖票，ticket=10
B卖票，ticket=9
C卖票，ticket=8
A卖票，ticket=7
B卖票，ticket=6
C卖票，ticket=5
A卖票，ticket=4
B卖票，ticket=4
C卖票，ticket=3
A卖票，ticket=2
B卖票，ticket=2
C卖票，ticket=1
*****票已经卖光了****
A卖票，ticket=0
*****票已经卖光了****
B卖票，ticket=-1          ！！！！！
*****票已经卖光了****

显然这不符合逻辑。

2.同步代码块

下面是用同步代码块的方式进行同步操作

下面是在run方法里把一块代码用Synchronized框起来。

使得只有当同步代码块里的的代码执行完了之后，其他线程才能对其中的资源进行处理。

class Mythread112 implements Runnable {

    private int ticket = 10;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {//同步代码块
                if (this.ticket > 0) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖票，ticket=" + this.ticket--);
                } else {
                    System.out.println("*****票已经卖光了****");
                    break;
                }
            }
        }
    }
}

public class ThreadLock {
    public static void main(String[] args) {
        Mythread112 mythread11 = new Mythread112();
        new Thread(mythread11, "A").start();
        new Thread(mythread11, "B").start();
        new Thread(mythread11, "C").start();
    }
}

结果：

A卖票，ticket=10
A卖票，ticket=9
A卖票，ticket=8
A卖票，ticket=7
A卖票，ticket=6
A卖票，ticket=5
A卖票，ticket=4
A卖票，ticket=3
A卖票，ticket=2
A卖票，ticket=1
*****票已经卖光了****
*****票已经卖光了****
*****票已经卖光了****

这里只出现A卖票是因为票太少了。如果有100，或1000张，肯定会有B和C。10张在多次执行后也会出现其他BC的卖票。

3.同步方法

同步方法就是在一个方法的声明中加synchronized

class Mythread12 implements Runnable {

    private int ticket = 10;
    public  synchronized boolean sale(){  //同步方法
        if (this.ticket > 0) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖票，ticket=" + this.ticket--);
            return true;
        } else {
            System.out.println("*****票已经卖光了****");
            return false;
        }
    }
    @Override
    public void run() {
        while (this.sale()) {
           ;
        }
    }
}

public class ThreadLock2 {
    public static void main(String[] args) {
        Mythread12 mythread11 = new Mythread12();
        new Thread(mythread11, "A").start();
        new Thread(mythread11, "B").start();
        new Thread(mythread11, "C").start();
    }
}

结果跟同步代码块一样

小结：

在执行速度上：同步处理后执行速率会明显下降。

同步代码块跟同步方法的速率，我粗略的用System.currentTimeMillis();测了一下没有区别。其实也没什么区别。

至于该用他们两中的哪一个，看具体情况吧，

1，java类库中很多类都是用的同步方法。

2，同步的开销比较大，同步方法会使整个方法同步，同步代码块会使方法中的一部分同步，为了追求极致的效率，同步代码块是一个可以选择的优化点。

3.其实多线程在上下文切换时也会使速率下降，这是一个需要斟酌的事情。

 

4、死锁

下面的死锁例子可能不太方便理解。同步是要执行完才释放资源的访问权，这就导致可能会使得双方都在等待对方释放资源，结果就僵住了。

一句话就是：多个线程访问同一资源时，需要做同步处理，然而过多的同步会造成死锁。

 

class Jian {
    public synchronized void say(XiaoQiang xq) {
        System.out.println("A说话");
        xq.get();
    }

    public synchronized void get() {
        System.out.println("A成功");
    }
}

class XiaoQiang {
    public synchronized void say(Jian jj) {
        System.out.println("B说话");
        jj.get();
    }

    public synchronized void get() {
        System.out.println("B成功");
    }
}

public class DeadLock implements Runnable {
    private Jian jj = new Jian();
    private XiaoQiang xq = new XiaoQiang();

    @Override
    public void run() {
        jj.say(xq);
    }
    public DeadLock(){
        new Thread(this).start();
        xq.say(jj);

    }

    public static void main(String[] args) {
        new DeadLock();
    }
}

 

 

 

 

笔记来自：java高级编程教学