JAVA--线程同步

　　继昨天线程介绍后，今天我又把线程中的同步问题总结了一下，现在就和大家一起探讨一下。

　　线程加锁有什么用处呢？举个例子：比如你现在有30000块大洋在银行存着，现在你到银行取钱，当你输入密码完成后，已经输入取款金额，比如你输入的是20000，就是在银行给你拿钱这个时刻，你老婆也去银行取这笔钱，你老婆同样取20000，因为此时你的账上仍然是30000，所以银行同样的操作在你老婆那端有进行了一遍，这样当你们两个完成各自操作后，银行记录的你账上还应该有10000块存款，这样是不是很爽。解决这个问题就用到了线程加锁的知识，下面就让我们一起来学习一下吧。

一、未处理线程同步的一个例子：

public class TextSync implements Runnable{

    /**未处理线程同步
     * @param args
     */
    Time time = new Time();
    public static void main(String[] args) {
        TextSync text = new TextSync();
        Thread t1 = new Thread(text);
        Thread t2 = new Thread(text);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        time.add(Thread.currentThread().getName());
    }
}
class Time {
    private static int num = 0;
    public void add(String name){
        try {
            num++;
            //当第一个线程执行到此时，num变成了1，第一个线程暂停一秒，
            //第二个线程开始执行，当第二个线程执行到此时，num变成了2，第二个线程暂停一秒，
            //第一个线程此时的num同样变成了2，所以最终的结果均为2；
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name+"是第"+num+"个执行的线程。");
    }
}

输出结果：

二、线程同步

public class TextSynctwo implements Runnable{

    /**线程同步
     * @param args
     */
    Time1 time = new Time1();
    public static void main(String[] args) {
        TextSynctwo text = new TextSynctwo();
        Thread t1 = new Thread(text);
        Thread t2 = new Thread(text);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        time.add(Thread.currentThread().getName());
    }
}
class Time1 {
    private static int num = 0;
    
    //synchronized锁定当前线程，可以在方法定义时进行声明，或采用在方法中进行设置。
    public synchronized void add(String name){
        //synchronized (this) {//锁定当前线程，防止此时被别的线程执行
            try {
                num++;
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name+"是第"+num+"个执行的线程。");
        //}
    }
}

输出结果：

三、死锁

public class TestDeadLock implements Runnable{

    /**死锁
     * @param args
     */
    private int flag = 0 ; 
    static Object o1 = new Object();
    static Object o2 = new Object();
    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock(); 
        TestDeadLock td2 = new TestDeadLock(); 
        td1.flag = 1;
        td2.flag = 2;
        Thread t1 = new Thread(td1); 
        Thread t2 = new Thread(td2);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
        if(flag == 1){
            synchronized(o1){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(o2){
                    System.out.println("1");
                }
            }
        }
        if(flag == 2){
            synchronized(o2){
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(o1){
                    System.out.println("2");
                }
            }
        }
    }
}

四、锁定

public class TT implements Runnable{

    /**锁定
     * @param args
     */
    int b = 100;
    public static void main(String[] args) {
        TT tt = new TT();
        Thread th = new Thread(tt);
        th.start();
        try {
            tt.m2();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println(tt.b);
    }

    @Override
    public void run() {
        try {
            m1();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    private synchronized void m1() throws Exception{
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b="+b);
    }
    private synchronized void m2() throws Exception{
        Thread.sleep(2500);
        b = 2500;
    } 
}

对于锁定这个我有一个疑问，还望大神们给予指点，现在的输出结果：

我想问的就是，问什么m2先执行，m1要等m2执行完毕后方可执行。

希望大家给予答复，谢谢