JAVA--线程同步

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执行完毕后方可执行。



希望大家给予答复，谢谢
http://www.cnblogs.com/AndroidJotting/p/3937019.html