java-synchronized-test

这个星期彻底弄明白了一件事, 是关于java的…

1.先来看下多线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class DisplayMessage implements Runnable {
    private String message;
    public DisplayMessage(String message) {
        this.message = message;
    }
    public void run() {
        while(true) {
            System.out.println(message);
            System.out.println(Thread.currentThread().getName());
        }
    }
}
public class GuessANumber extends Thread {
    private int number;
    public GuessANumber(int number) {
        this.number = number;
    }
    public void run() {
        int counter = 0;
        int guess = 0;
        do {
            guess = (int) (Math.random() * 100 + 1);
            System.out.println(this.getName() + " guesses " + guess);
            counter++;
        } while(guess != number);
        System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
    }
}

以上是实现多线程的2种方式, 区别是用runnable可以去再集成一个其他类.

2.静态测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class ThreadClassDemo {
    public static void main(String [] args) {
        System.out.println("Starting thread3...");
        Thread thread3 = new GuessANumber(27);
        thread3.start();
        try {
            //此操作  强制占据主动权  只有带该线程完毕后才会执行下面的线程
            //强制占据100ms 100ms后该线程任务未完成  直接进入下一个线程 可以看出每次计算次数也不一样
            thread3.join(100);
        }catch(InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
        // 下面2个线程都用了while 需要设置守护线程不然停不下来。。。
        Runnable hello = new DisplayMessage("Hello");
        Thread thread1 = new Thread(hello);
        thread1.setDaemon(true);
        thread1.setName("hello");
        System.out.println("Starting hello thread...");
        thread1.start();
        Runnable bye = new DisplayMessage("Goodbye");
        Thread thread2 = new Thread(bye);
        //thread2.setPriority(Thread.MIN_PRIORITY);
        thread2.setDaemon(true);
        System.out.println("Starting goodbye thread...");
        thread2.start();
        System.out.println("Starting thread4...");
        Thread thread4 = new GuessANumber(75);
        //thread4.setDaemon(true);
        thread4.start();
        System.out.println("main() is ending...");
    }
}

上述有四个线程, 输出结果应该是杂乱无章的, thread3实行了强制禁令, join…
一个进程只有等待其所有非守护线程结束才能终止, 这也是为什么2个while的进程需要setDaemon(true)。

3.言归正传, 这次的课程的是synchronized,会通过几个例子说明。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class SyncThread implements Runnable {
    @Override
    public void run() {
        String threadName = Thread.currentThread().getName();
        if (threadName.startsWith("A")) {
            async();
        } else if (threadName.startsWith("B")) {
            sync1();
        } else if (threadName.startsWith("C")) {
            sync2();
        } 
    }
    /**
     * 方法中有 synchronized(this|object) {} 同步代码块
     */
    private void sync1() {
        synchronized(SyncThread.this) {
            System.out.println(Thread.currentThread().getName() + "_Sync1: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            try {
                System.out.println(Thread.currentThread().getName() + "_Sync1_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "_Sync1_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * synchronized 修饰非静态方法
     */
    private synchronized void sync2() {
        System.out.println(Thread.currentThread().getName() + "_Sync2: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync2_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync2_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
        public static void main(String... args) {
            SyncThread syncThread = new SyncThread();
            Thread B_thread1 = new Thread(syncThread, "B_thread1");
            Thread B_thread2 = new Thread(syncThread, "B_thread2");
            Thread C_thread1 = new Thread(syncThread, "C_thread1");
            Thread C_thread2 = new Thread(syncThread, "C_thread2");
            B_thread1.start();
            B_thread2.start();
            C_thread1.start();
            C_thread2.start();
        }
        //上述同步的是同一个对象 所有必须等待上一个执行完
}

上述展示了2种同步代码块的写法, 猜猜输出结果吧
B_thread1 B_thread1_Sync2_Start B_thread1_Sync2_End
需要注意的是上一个锁定对象执行的方法需要等下一个执行完才行。

4.咱们改改代码

1
2
3
4
5
6
7
8
9
10
11
public static void main(String... args) {
     Thread B_thread1 = new Thread(new SyncThread(), "B_thread1");
     Thread B_thread2 = new Thread(new SyncThread(), "B_thread2");
     Thread C_thread1 = new Thread(new SyncThread(), "C_thread1");
     Thread C_thread2 = new Thread(new SyncThread(), "C_thread2");
     B_thread1.start();
     B_thread2.start();
     C_thread1.start();
     C_thread2.start();
 }

因为是四个不同的对象, 所以执行起来就是异步了的。

5.再来改一下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
private void sync1() {
        synchronized(SyncThread.Class) {
            System.out.println(Thread.currentThread().getName() + "_Sync1: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            try {
                System.out.println(Thread.currentThread().getName() + "_Sync1_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "_Sync1_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * synchronized 修饰静态方法
     */
    private synchronized static void sync2() {
        System.out.println(Thread.currentThread().getName() + "_Sync2: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync2_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync2_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
     public static void main(String... args) {
            Thread B_thread1 = new Thread(new SyncThread(), "B_thread1");
            Thread B_thread2 = new Thread(new SyncThread(), "B_thread2");
            Thread C_thread1 = new Thread(new SyncThread(), "C_thread1");
            Thread C_thread2 = new Thread(new SyncThread(), "C_thread2");
            B_thread1.start();
            B_thread2.start();
            C_thread1.start();
            C_thread2.start();
        }

尽管上面是四个不同的对象, 但是注意方法是静态方法, 而且synchronized(SyncThread.Class)锁定的是类, 所以其实也是同步执行的。
有人说试试相同对象, 结果是一样的。

6.再来看最后一种情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
private void sync1() {
        synchronized(SyncThread.Class) {
            System.out.println(Thread.currentThread().getName() + "_Sync1: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            try {
                System.out.println(Thread.currentThread().getName() + "_Sync1_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName() + "_Sync1_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * synchronized 修饰静态方法
     */
    private synchronized void sync2() {
        System.out.println(Thread.currentThread().getName() + "_Sync2: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        try {
            System.out.println(Thread.currentThread().getName() + "_Sync2_Start: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + "_Sync2_End: " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
     public static void main(String... args) {
            Thread B_thread1 = new Thread(new SyncThread(), "B_thread1");
            Thread B_thread2 = new Thread(new SyncThread(), "B_thread2");
            Thread C_thread1 = new Thread(new SyncThread(), "C_thread1");
            Thread C_thread2 = new Thread(new SyncThread(), "C_thread2");
            B_thread1.start();
            B_thread2.start();
            C_thread1.start();
            C_thread2.start();
        }

上面该是如何执行的呢？ 其实只要明白一点就行了, 对象锁和类锁是独立的，互不干扰。
今天就到这, 以后博客还是会放在前端的react技术站上.

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家