java多线程同步

用卖票演示同步代码块

package javase;

class Ticket implements Runnable{
    
    private int num = 100;
    
    private Object obj = new Object();
    
    public void run() {
        
        show();
    }
    
    public void show() {
        
        while(true) {
            
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj) {
            
                if(num>0)
                    System.out.println(Thread.currentThread().getName()+" ticket="+num--);
            }
        }
        
    }
    
}

public class ThreadDemo2 {

    public static void main(String[] args) {
        
        Ticket t = new Ticket();
        
        Thread t1 = new Thread(t);
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t);
        
        t1.start();
        t2.start();
        t3.start();
        
    }

}

创建三个线程对一个对象执行任务，即共用一个数据域。在执行 while(num>0)语句时，假设此时num=1，线程1进入并暂停运行。而此时num=1，线程2进入执行 num--，使得num=0输出打印。当线程1执行时，已经通过while语句的判断了，直接执行 num-- 输出打印，从而打印了0，出现错误。

使用线程同步块，在synchronized语句中只有一个线程进入，此时synchronized会给出判断结果，阻挡其他线程进入synchronized下的代码块，也就使得while语句每次都能执行完，避免错误。

演示同步函数

class Tickets implements Runnable{
    
    private int num = 100;
    
    public void run() {
        while(true) {
            
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            show();
        
        }
    }
    
    public synchronized void show() {
        
        if(num>0)
            System.out.println(Thread.currentThread().getName()+" ticket="+num--);
    }
}

在函数上加上修饰符synchronized，使得函数变成同步函数。与同步代码块不同的是：同步代码块可以使用任意的对象作为锁，而同步函数只能使用本类的this作为锁。

当同步函数是静态的时候，此时要保证两种同步都要使用一个锁，就可以用this.getClass()、类.class作为锁

死锁：

package javase;

class LockObject{
    public static final Object obj1 = new Object();
    public static final Object obj2 = new Object();
}

class DeadLock implements Runnable{
    
    private boolean falg;
    public DeadLock(boolean falg) {
        this.falg = falg;
    }
    
    @Override
    public void run() {
        
        if(falg) {
            while(true)
                synchronized (LockObject.obj1) {
                    System.out.println("if---obj1");
                    synchronized (LockObject.obj2) {
                        System.out.println("if---obj2");
                    }
                }
            
        }
        else {
            while(true)
                synchronized (LockObject.obj2) {
                    System.out.println("else---obj2");
                    synchronized (LockObject.obj1) {
                        System.out.println("else---obj1");
                    }
                }
        }
        
    }
    
}

public class DeadLockTest {

    public static void main(String[] args) {
        
        DeadLock d1 = new DeadLock(true);
        DeadLock d2 = new DeadLock(false);
        
        Thread t1 = new Thread(d1);
        Thread t2 = new Thread(d2);
        
        t1.start();
        t2.start();
        
    }

}

死锁是因为两个以上的锁在互相调用，线程a进入后并没有释放当前它所使用的锁1。此时另线程b获得执行权进入，他拿到了自己的锁2后，准备进入锁1时发现锁1还在被线程a使用，而线程a发现锁2也被线程b使用了。造成互相拿着锁使得别人和自己也无法进入的现象