簡單聊聊 Java線程的并發(fā)

哈嘍大家好，上一篇文章我們聊了聊Java線程的基礎(chǔ)知識贡茅，這一篇文章我們就來聊聊線程中的線程安全問題

線程安全問題

線程安全問題一般指的是多個線程同時對同一個變量進(jìn)行操作的時候可能會出現(xiàn)問題城菊。

我們先舉個簡單的例子來說說什么是線程安全問題：

public class symain {

    public static int a = 0;

    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread1 = new Thread(testThread,"A");
        Thread thread2 = new Thread(testThread,"B");
        Thread thread3 = new Thread(testThread,"C");
        thread1.start();
        thread2.start();
        thread3.start();
    }

    public static class TestThread extends Thread {

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                a++;
                System.out.println(currentThread().getName()+" a = "+a);
            }
        }
    }
}

結(jié)果為：

A a = 2
B a = 2
B a = 4
......

代碼中a為公共變量备燃，三個線程分別用for循環(huán)對a進(jìn)行a++操作，結(jié)果中我們發(fā)現(xiàn)A和B同時出現(xiàn)了a為2的情況凌唬，這就是a的數(shù)據(jù)并沒有及時同步到每一個線程并齐，這就是我們所說的線程安全問題。

方法內(nèi)部變量不存在線程安全問題

我們知道了線程安全問題的一個關(guān)鍵是對同一個變量進(jìn)行操作客税，那么變量如果在方法內(nèi)部况褪，就不會造成線程安全問題了，雖然是同一個對象霎挟，但是方法中的變量是臨時生成的窝剖，每調(diào)用一次方法就生成一個新的變量，所以不會造成線程安全問題酥夭，下面用代碼驗證下：

public class Test {
    
    public void test() {
        int a = 0;

        for (int i = 0; i < 10; i++) {
            a++;
            System.out.println(Thread.currentThread().getName() + " a = " + a);
        }
    }
}

public class symain {

    public static void main(String[] args) {
        Test test = new Test();
        TestThread testThread1 = new TestThread(test);
        TestThread testThread2 = new TestThread(test);
        TestThread testThread3 = new TestThread(test);
        testThread1.start();
        testThread2.start();
        testThread3.start();
    }

    public static class TestThread extends Thread {

        private Test test;

        public TestThread(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            test.test();
        }
    }
}

結(jié)果為：

Thread-0 a = 1
Thread-2 a = 1
Thread-2 a = 2
Thread-1 a = 1
Thread-1 a = 2
Thread-1 a = 3
Thread-2 a = 3
Thread-0 a = 2
Thread-2 a = 4
Thread-1 a = 4
Thread-2 a = 5
Thread-0 a = 3
Thread-2 a = 6
Thread-1 a = 5
Thread-1 a = 6
Thread-1 a = 7
Thread-1 a = 8
Thread-1 a = 9
Thread-1 a = 10
Thread-2 a = 7
Thread-0 a = 4
Thread-0 a = 5
Thread-2 a = 8
Thread-0 a = 6
Thread-0 a = 7
Thread-2 a = 9
Thread-0 a = 8
Thread-2 a = 10
Thread-0 a = 9
Thread-0 a = 10

我們可以看到雖然因為多線程執(zhí)行的順序有變化，但是每一個線程中的a是沒有問題的脊奋。所以當(dāng)變量在方法中的時候熬北，是不存在線程安全問題的。

synchronized解決線程安全問題

那么有什么方法解決第一個例子的線程安全問題呢诚隙？Java為我們提供了關(guān)鍵字synchronized,我們在方法前加上這個關(guān)鍵字：

    public static class TestThread extends Thread {

        @Override
        synchronized public void run() {
            for (int i = 0; i < 10; i++) {
                a++;
                System.out.println(currentThread().getName()+" a = "+a);
            }
        }
    }

看下運行的結(jié)果：

A a = 1
A a = 2
A a = 3
A a = 4
A a = 5
A a = 6
A a = 7
A a = 8
A a = 9
A a = 10
C a = 11
C a = 12
C a = 13
C a = 14
C a = 15
C a = 16
C a = 17
C a = 18
C a = 19
C a = 20
B a = 21
B a = 22
B a = 23
B a = 24
B a = 25
B a = 26
B a = 27
B a = 28
B a = 29
B a = 30

上面的問題解決了讶隐。

synchronized對象鎖

我們接下來看一個例子：

public class Test {

    synchronized public void test1() {
        try {
            System.out.println("test1 start");
            Thread.sleep(2000);
            System.out.println("test1 end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void test2() {
        System.out.println("test2 start");
        System.out.println("test2 end");
    }
}

public class symain {

    public static void main(String[] args) {
        Test test = new Test();
        ThreadA threadA = new ThreadA(test);
        ThreadB threadB = new ThreadB(test);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            test.test2();
        }
    }
}

結(jié)果為：

test1 start
test1 end
test2 start
test2 end

我們看到運行結(jié)果是按順序運行的，證明同一個對象中久又，在方法前面加入了synchronized巫延，這些方法獲取的是同一個鎖，并且他們獲取的是對象鎖地消。下面我們通過代碼來驗證下：

    public void test2() {
        synchronized (this) {
            System.out.println("test2 start");
            System.out.println("test2 end");
        }
    }

結(jié)果為：

test1 start
test1 end
test2 start
test2 end

驗證了在方法前加synchronized和synchronized(this)的效果是相同的炉峰，他們都是以當(dāng)前類生成的對象為監(jiān)視器的，并且這種鎖都是對象鎖脉执。

對象鎖還有一個特性疼阔，那就是多個對象多個鎖，我們來看一段代碼：

public class Test {

    synchronized public void test1() {
        try {
            System.out.println("test1 start");
            Thread.sleep(2000);
            System.out.println("test1 end");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized public void test2() {
        System.out.println("test2 start");
        System.out.println("test2 end");
    }
}

public class symain {

    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        ThreadA threadA = new ThreadA(test1);
        ThreadB threadB = new ThreadB(test2);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            test.test2();
        }
    }
}

結(jié)果為：

test1 start
test2 start
test2 end
test1 end

當(dāng)我們傳入的Test并不是同一個對象的時候半夷，結(jié)果也并不是按順序打印婆廊，因為兩個對象分別拿的是兩個不同的鎖。

synchronized鎖重入

在擁有相同鎖的前提下巫橄，加了鎖的方法內(nèi)部依然可以調(diào)用擁有相同鎖的方法淘邻，下面我們來看看代碼：

public class Test {

    synchronized public void test1() {
       System.out.println("in test1");
       test2();
    }

    synchronized public void test2() {
        System.out.println("in test2");
        test3();
    }

    synchronized public void test3(){
        System.out.println("in test3");
    }
}

public class symain {

    public static void main(String[] args) {
        Test test1 = new Test();
       ThreadTest threadTest = new ThreadTest(test1);
       threadTest.start();
    }

    public static class ThreadTest extends Thread {

        private Test test;

        public ThreadTest(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            test.test1();
        }
    }
}

結(jié)果為：

in test1
in test2
in test3

上面的代碼證明了擁有相同鎖的方法之間是可以互相調(diào)用的。

子類和父類之間也是可以實現(xiàn)鎖重入的湘换，我們來看看代碼：

public class Test {

    synchronized public void test1() {
       System.out.println("in test1");
    }
}

public class TestMin extends Test {

    synchronized public void test2() {
        System.out.println("in test2");
        test1();
    }
}

public class symain {

    public static void main(String[] args) {
        TestMin testMin = new TestMin();
        ThreadA threadA = new ThreadA(testMin);
        threadA.start();
    }

    public static class ThreadA extends Thread {

        private TestMin testMin;

        public ThreadA(TestMin testMin) {
            this.testMin = testMin;
        }

        @Override
        public void run() {
            testMin.test2();
        }
    }
}

結(jié)果為：

in test2
in test1

我們可以看到在test2方法中還沒有釋放當(dāng)前鎖宾舅，我們成功的調(diào)用了父類的方法test1敬尺，證明了父類和子類之間也可以實現(xiàn)鎖重入。

異常會釋放鎖

如果加鎖的代碼中出現(xiàn)了異常贴浙，那么這個鎖就會自動釋放掉砂吞，下面我們來看看代碼：

public class Test {

    synchronized public void test1() {
        System.out.println("test1 start");
        int a = 100;

        while (true) {
            int b = 20 / a--;
            System.out.println("test1 b = " + b);
        }
    }

    synchronized public void test2() {
        System.out.println("in test2");
    }
}

public class symain {

    public static void main(String[] args) {
        Test test = new Test();
        ThreadA threadA = new ThreadA(test);
        ThreadB threadB = new ThreadB(test);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test2();
        }
    }
}

結(jié)果為：

......
test1 b = 10
test1 b = 20
Exception in thread "Thread-0" java.lang.ArithmeticException: / by zero
    at Sydemo.Test.test1(Test.java:10)
    at Sydemo.symain$ThreadA.run(symain.java:24)
in test2

我們可以看到，早報錯過后test1方法釋放了鎖崎溃，test2方法才開始運行蜻直。

同步不具有繼承性

子類重寫了父類的方法，如果父類方法前加了synchronized袁串，那么子類方法中也必須加synchronized概而，要不就不具有鎖的效果，我們來看看代碼：

public class Test {

    synchronized public void test1() {
       try {
           System.out.println("test1 start");
           Thread.sleep(2000);
           System.out.println("test1 end");
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

public class TestMin extends Test {

    @Override
    public void test1() {
        try {
            System.out.println("test1 start");
            Thread.sleep(2000);
            System.out.println("test1 end");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    synchronized public void test2() {
        System.out.println("test2 start");
        System.out.println("test2 end");
    }
}

public class symain {

    public static void main(String[] args) {
        TestMin testMin = new TestMin();
        ThreadA threadA = new ThreadA(testMin);
        ThreadB threadB = new ThreadB(testMin);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private TestMin testMin;

        public ThreadA(TestMin testMin) {
            this.testMin = testMin;
        }

        @Override
        public void run() {
            super.run();
            testMin.test1();
        }
    }

    public static class ThreadB extends Thread {

        private TestMin testMin;

        public ThreadB(TestMin testMin) {
            this.testMin = testMin;
        }

        @Override
        public void run() {
            super.run();
            testMin.test2();
        }
    }
}

結(jié)果為：

test1 start
test2 start
test2 end
test1 end

我們可以看到test1還沒有執(zhí)行完成test2已經(jīng)執(zhí)行完成了囱修，證明鎖并沒有起作用赎瑰，我們將子類的test1方法加上synchronized試試。

    @Override
    public synchronized void test1() {
        try {
            System.out.println("test1 start");
            Thread.sleep(2000);
            System.out.println("test1 end");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

結(jié)果為：

test1 start
test1 end
test2 start
test2 end

這樣才是正確的破镰，所以子類在重寫父類帶有synchronized關(guān)鍵字方法的時候餐曼，也要加上synchronized關(guān)鍵字才行。

任意對象為對象監(jiān)視器

對象監(jiān)視器是什么呢鲜漩，我們在使用synchronized(this)的時候源譬，傳入的this就是對象監(jiān)視器，這個傳入的值可以為任意值孕似。我們一般會使用一個對象踩娘，或者是一個變量來充當(dāng)這個對象監(jiān)視器，下面我們舉個例子：

public class Test {

    private final Object object = new Object();

    public void test1() {
        synchronized (object){
            try {
                System.out.println("test1 start");
                Thread.sleep(2000);
                System.out.println("test1 end");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void test2() {
        synchronized (object){
            System.out.println("test2 start");
            System.out.println("test2 end");
        }
    }
}

public class symain {

    public static void main(String[] args) {
        Test test = new Test();
        ThreadA threadA = new ThreadA(test);
        ThreadB threadB = new ThreadB(test);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test2();
        }
    }
}

結(jié)果為：

test1 start
test1 end
test2 start
test2 end

我們在以object為對象監(jiān)視器的時候喉祭，鎖是起了作用的养渴。需要注意的是要用同一個對象當(dāng)監(jiān)視器才行，如果是不同的對象泛烙，鎖則不起作用理卑。

方法前添加synchronized也有可能出現(xiàn)線程不安全

上面我們都說添加synchronized過后，線程就是安全的胶惰，但是有時候也會有特殊情況傻工，這也是線程安全的難點，到處都是細(xì)節(jié)啊孵滞。我們下面來看個例子：

public class Test {

    private List<Integer> list = new ArrayList<>();

    synchronized void addList() {
        list.add(1);
    }

    synchronized Integer getList() {
        return list.size();
    }
}

public class symain {

    public static void main(String[] args) {
        try {
            Test test = new Test();
            ThreadA threadA = new ThreadA(test);
            ThreadB threadB = new ThreadB(test);
            threadA.start();
            threadB.start();
            Thread.sleep(6000);
            System.out.println(test.getList());
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            try {
                if (test.getList() < 1) {
                    Thread.sleep(2000);
                    test.addList();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            try {
                if (test.getList() < 1) {
                    Thread.sleep(2000);
                    test.addList();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

結(jié)果為：

我們在Test類中的兩個方法都加入了synchronized關(guān)鍵字中捆，這兩個方法的調(diào)用時線程安全的，但是我們在調(diào)用的時候有一個時間差坊饶，就造成了最后的錯誤泄伪，像這種情況，我們可以用synchronized代碼塊來解決：

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            synchronized (test) {
                try {
                    if (test.getList() < 1) {
                        Thread.sleep(2000);
                        test.addList();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            synchronized (test) {
                try {
                    if (test.getList() < 1) {
                        Thread.sleep(2000);
                        test.addList();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

我們線程中加入了以test為線程監(jiān)視器的synchronized代碼塊匿级，我們來看看結(jié)果：

最后結(jié)果為正常的蟋滴。

synchronized靜態(tài)方法和synchronized(.Class)

synchronized如果加在靜態(tài)方法前面染厅，線程監(jiān)視器就為當(dāng)前類，我們舉個例子：

public class Test {

    public synchronized static void test1() {
        try {
            System.out.println("test1 start");
            Thread.sleep(2000);
            System.out.println("test2 end");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void test2() {
        synchronized (Test.class) {
            System.out.println("test2 start");
            System.out.println("test2 end");
        }
    }
}

public class symain {

    public static void main(String[] args) {

        Test test = new Test();
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB(test);
        threadA.start();
        threadB.start();

    }

    public static class ThreadA extends Thread {

        @Override
        public void run() {
            super.run();
            Test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test2();
        }
    }
}

結(jié)果為：

test1 start
test1 end
test2 start
test2 end

證明了他們的線程監(jiān)視器都是Test.Class這個類津函。

當(dāng)使用類當(dāng)線程監(jiān)視器的時候肖粮，對這個類的所有對象都是起作用的，下面我們來看看代碼：

public class Test {

    public void test1() {
        synchronized (Test.class) {
            try {
                System.out.println("test1 start");
                Thread.sleep(2000);
                System.out.println("test1 end");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void test2() {
        synchronized (Test.class) {
            System.out.println("test2 start");
            System.out.println("test2 end");
        }
    }
}

public class symain {

    public static void main(String[] args) {
        Test test1 = new Test();
        Test test2 = new Test();
        ThreadA threadA = new ThreadA(test1);
        ThreadB threadB = new ThreadB(test2);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test2();
        }
    }
}

結(jié)果為：

test1 start
test1 end
test2 start
test2 end

我們傳入的是兩個不同的Test對象尔苦，但是最后的結(jié)果是同步的涩馆。所以這也驗證了我們上面的說法。

死鎖

死鎖簡單來說就是在使用synchronized的時候允坚，因為使用不正確而造成進(jìn)入有鎖的方法后就無法出來了魂那。我們舉個例子來說明一下：

public class Test {

    private final Object object1 = new Object();
    private final Object object2 = new Object();

    public void test1() {

        synchronized (object1) {
            try {
                System.out.println("進(jìn)入了test1第一次鎖");
                Thread.sleep(2000);
                synchronized (object2) {
                    System.out.println("進(jìn)入了test1的第二層鎖");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void test2() {

        synchronized (object2) {
            try {
                System.out.println("進(jìn)入了test2第一次鎖");
                Thread.sleep(2000);
                synchronized (object1) {
                    System.out.println("進(jìn)入了test2的第二層鎖");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

public class symain {

    public static void main(String[] args) {
        Test test = new Test();
        ThreadA threadA = new ThreadA(test);
        ThreadB threadB = new ThreadB(test);
        threadA.start();
        threadB.start();
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test2();
        }
    }
}

結(jié)果為：

進(jìn)入了test1第一次鎖
進(jìn)入了test2第一次鎖

結(jié)果明顯是代碼沒有走完，就一直困在了方法里面稠项。我們來稍微分析一下涯雅，當(dāng)?shù)谝粋€線程進(jìn)入第一個方法的時候，持有了對象監(jiān)視器為object1這個鎖展运，然后準(zhǔn)備等待2s后進(jìn)入對象監(jiān)視器為object2的這個鎖活逆，但是還沒有到2s，第二個線程就進(jìn)入了方法并且持有了對象監(jiān)視器為object2的這個鎖乐疆，這就造成了線程一要等線程二執(zhí)行完這個方法并釋放對象監(jiān)視器為object2的鎖后才能才能繼續(xù)往下執(zhí)行划乖。但是線程二中也同樣在等待線程一執(zhí)行完成，釋放對象監(jiān)視器為object1的鎖挤土，所以他們就相互在等待，最后就困在了方法里面误算。

對象鎖仰美，對象的參數(shù)變化不會影響到鎖

我們在使用任意一個對象為線程監(jiān)視器的時候，如果我們修改了對象中的屬性儿礼，并不會影響同步咖杂，我們舉個例子：

public class User {

    private String name;
    private int age;

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }
}

public class Test {

    private final User user = new User();

    public Test() {
        user.setName("AAA");
        user.setAge(7);
    }

    public void test1() {

        synchronized (user) {
            try {
                System.out.println("test1 start");
                Thread.sleep(2000);
                System.out.println("test1 end");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void test2() {

        synchronized (user) {
            System.out.println("test2 start");
            System.out.println("test2 end");
        }
    }

    public void changeUser() {
        user.setAge(user.getAge() + 10);
        System.out.println("age修改為:" + user.getAge());
    }
}

public class symain {

    public static void main(String[] args) {
        try {
            Test test = new Test();
            ThreadA threadA = new ThreadA(test);
            ThreadB threadB = new ThreadB(test);
            threadA.start();
            Thread.sleep(500);
            test.changeUser();
            threadB.start();
        } catch (Exception e) {
            e.printStackTrace();

        }
    }

    public static class ThreadA extends Thread {

        private Test test;

        public ThreadA(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test1();
        }
    }

    public static class ThreadB extends Thread {

        private Test test;

        public ThreadB(Test test) {
            this.test = test;
        }

        @Override
        public void run() {
            super.run();
            test.test2();
        }
    }
}

結(jié)果為：

test1 start
age修改為:17
test1 end
test2 start
test2 end

我們可以看到執(zhí)行順序依然是正常的。

有關(guān)synchronized關(guān)鍵字和線程安全的知識點就講的差不多了蚊夫，如果上文中有錯誤的地方歡迎大家指出诉字。

3Q

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市知纷，隨后出現(xiàn)的幾起案子壤圃，更是在濱河造成了極大的恐慌，老刑警劉巖琅轧，帶你破解...
沈念sama閱讀 216,591評論 6贊 501
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件伍绳，死亡現(xiàn)場離奇詭異，居然都是意外死亡乍桂，警方通過查閱死者的電腦和手機(jī)冲杀，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 92,448評論 3贊 392
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進(jìn)店門效床，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人权谁，你說我怎么就攤上這事剩檀。” “怎么了旺芽？”我有些...
開封第一講書人閱讀 162,823評論 0贊 353
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵沪猴，是天一觀的道長。經(jīng)常有香客問我甥绿，道長字币，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 58,204評論 1贊 292
?港島之戀（遺憾婚禮）
正文為了忘掉前任共缕，我火速辦了婚禮洗出，結(jié)果婚禮上，老公的妹妹穿的比我還像新娘图谷。我一直安慰自己翩活，他們只是感情好，可當(dāng)我...
茶點故事閱讀 67,228評論 6贊 388
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布便贵。她就那樣靜靜地躺著菠镇，像睡著了一般。火紅的嫁衣襯著肌膚如雪承璃。梳的紋絲不亂的頭發(fā)上利耍，一...
開封第一講書人閱讀 51,190評論 1贊 299
城市分裂傳說
那天，我揣著相機(jī)與錄音盔粹，去河邊找鬼隘梨。笑死，一個胖子當(dāng)著我的面吹牛舷嗡，可吹牛的內(nèi)容都是我干的轴猎。我是一名探鬼主播，決...
沈念sama閱讀 40,078評論 3贊 418
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼进萄，長吁一口氣：“原來是場噩夢啊……” “哼捻脖！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起中鼠，我...
開封第一講書人閱讀 38,923評論 0贊 274
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤可婶，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后兜蠕，有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體扰肌，經(jīng)...
沈念sama閱讀 45,334評論 1贊 310
?護(hù)林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點故事閱讀 37,550評論 2贊 333
?白月光啟示錄
正文我和宋清朗相戀三年熊杨，在試婚紗的時候發(fā)現(xiàn)自己被綠了曙旭。大學(xué)時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片盗舰。...
茶點故事閱讀 39,727評論 1贊 348
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖桂躏，靈堂內(nèi)的尸體忽然破棺而出钻趋，到底是詐尸還是另有隱情，我是刑警寧澤剂习，帶...
沈念sama閱讀 35,428評論 5贊 343
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布蛮位，位于F島的核電站，受9級特大地震影響鳞绕，放射性物質(zhì)發(fā)生泄漏失仁。R本人自食惡果不足惜，卻給世界環(huán)境...
茶點故事閱讀 41,022評論 3贊 326
男人毒藥：我在死后第九天來索命
文/蒙蒙一们何、第九天我趴在偏房一處隱蔽的房頂上張望萄焦。院中可真熱鬧，春花似錦冤竹、人聲如沸拂封。這莊子的主人今日做“春日...
開封第一講書人閱讀 31,672評論 0贊 22
一樁弒父案鹦蠕，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽冒签。三九已至，卻和暖如春钟病，著一層夾襖步出監(jiān)牢的瞬間萧恕，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 32,826評論 1贊 269
情欲美人皮
我被黑心中介騙來泰國打工肠阱，沒想到剛下飛機(jī)就差點兒被人妖公主榨干…… 1. 我叫王不留廊鸥，地道東北人。一個月前我還...
沈念sama閱讀 47,734評論 2贊 368
代替公主和親
正文我出身青樓辖所，卻偏偏與公主長得像，于是被迫代替她去往敵國和親磨德。傳聞我的和親對象是個殘疾皇子缘回，可洞房花燭夜當(dāng)晚...
茶點故事閱讀 44,619評論 2贊 354

簡單聊聊 Java線程的并發(fā)

線程安全問題

方法內(nèi)部變量不存在線程安全問題

synchronized解決線程安全問題

synchronized對象鎖

synchronized鎖重入

異常會釋放鎖

同步不具有繼承性

任意對象為對象監(jiān)視器

方法前添加synchronized也有可能出現(xiàn)線程不安全

synchronized靜態(tài)方法和synchronized(.Class)

死鎖

對象鎖仰美，對象的參數(shù)變化不會影響到鎖

3Q

推薦閱讀更多精彩內(nèi)容