10.并发编程之线程八锁

Leefs 2022-10-10 PM 643℃ 0条

[TOC]

#### 示例一

> **程序运行结果为：1 2 或 2 1**。

```java
@Slf4j(topic = "c.ThreadLockDemo01")
public class ThreadLockDemo01 {
    public static void main(String[] args) {
        Number1 n1 = new Number1();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
    }
}

@Slf4j(topic = "c.Number1")
class Number1{
    public synchronized void a(){
        log.debug("1");
    }
    public synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

**在成员函数上添加synchronized关键子，相当于锁住this对象**，因此上述代码锁住的是同一对象`n1`，具有互斥性。

#### 示例二

> **程序运行结果为：1s后1 2 或 2 1s后1**。

```java
@Slf4j(topic = "c.ThreadLockDemo02")
public class ThreadLockDemo02 {
    public static void main(String[] args) {
        Number2 n1 = new Number2();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
    }
}

@Slf4j(topic = "c.Number2")
class Number2{
    public synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

**与情况1类似，锁住的也是同一对象，具有互斥性**。如果线程1先抢占到CPU，结果为1秒后1 2，如果线程2先抢占到CPU，结果为2 1秒后1

#### 示例三

> **程序运行结果为：3 1s后1 2，或 2 3 1s后1 或3 2 1s后1。**

```java
@Slf4j(topic = "c.ThreadLockDemo03")
public class ThreadLockDemo03 {
    public static void main(String[] args) {
        Number3 n1 = new Number3();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
        new Thread(() -> {n1.c();}).start();
    }
}

@Slf4j(topic = "c.Number3")
class Number3{
    public synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public synchronized void b(){
        log.debug("2");
    }
    public void c(){
        log.debug("3");
    }
}
```

**分析**

方法a和方法b上均添加有synchronized关键子，因此锁住的是this对象，具有互斥性，但是方法c没有添加synchronized关键子，因此不会受**对象锁**的影响。

#### 示例四

> **程序运行结果为:2 1s后1**。

```java
@Slf4j(topic = "c.ThreadLockDemo04")
public class ThreadLockDemo04 {
    public static void main(String[] args) {
        Number4 n1 = new Number4();
        Number4 n2 = new Number4();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n2.b();}).start();
    }
}

@Slf4j(topic = "c.Number4")
class Number4{
    public synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

**synchronized关键字添加到成员函数上，锁住的是this对象。**但是，程序中有两个不同的Number对象n1和n2,因此锁住的是不同的对象，不具有互斥性。

#### 示例五

> **程序运行结果为:2 1s后1**。

```java
@Slf4j(topic = "c.ThreadLockDemo05")
public class ThreadLockDemo05 {
    public static void main(String[] args) {
        Number5 n1 = new Number5();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
    }
}

@Slf4j(topic = "c.Number5")
class Number5{
    public static synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

**synchronized放到静态方法上，锁住的是类对象，放到成员方法上，锁住的是this对象。**因此锁住的是不同的对象，不具有互斥性。

#### 示例六

> **程序运行结果为：1S后1 2 或 2 1S后1。**

```java
@Slf4j(topic = "c.ThreadLockDemo06")
public class ThreadLockDemo06 {
    public static void main(String[] args) {
        Number6 n1 = new Number6();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n1.b();}).start();
    }
}

@Slf4j(topic = "c.Number6")
class Number6{
    public static synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

**synchronized放到静态方法上，锁住的是类对象，而java中类对象在内存中只有一份，因此锁住的是同一对象。**

#### 示例七

> **程序运行结果为：2 1S后1。**

```java
@Slf4j(topic = "c.ThreadLockDemo07")
public class ThreadLockDemo07 {
    public static void main(String[] args) {
        Number7 n1 = new Number7();
        Number7 n2 = new Number7();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n2.b();}).start();
    }
}

@Slf4j(topic = "c.Number7")
class Number7{
    public static synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

方法a锁住的是类对象，方法b锁住的是this对象。线程1调用`n1.a()`,锁住的是类对象，而线程2调用的是`n2.b()`对象，锁住的是n2对象，不具有互斥性。

#### 示例八

> **程序运行结果为：1S后1 2 或2 1S后1。**

```java
@Slf4j(topic = "c.ThreadLockDemo08")
public class ThreadLockDemo08 {
    public static void main(String[] args) {
        Number8 n1 = new Number8();
        Number8 n2 = new Number8();
        new Thread(() -> {n1.a();}).start();
        new Thread(() -> {n2.b();}).start();
    }
}

@Slf4j(topic = "c.Number8")
class Number8{
    public static synchronized void a(){
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b(){
        log.debug("2");
    }
}
```

**分析**

以上代码方法a()和方法b()都是static方法，因此锁住的都是类对象，虽然主程序创建了两个不同的Number对象n1和n2，但是类对象在java内存中只有一份，因此锁住的是同一对象。

*附原文地址：*

*《黑马程序员并发编程》*

标签: 并发编程

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/2474.html

上一篇 09.并发编程之共享问题

下一篇 11.并发编程之变量的线程安全分析

10.并发编程之线程八锁

评论啦~

栏目分类

标签云

友情链接申请

10.并发编程之线程八锁

 评论啦~

 栏目分类

标签云

友情链接申请

评论啦~

栏目分类

标签云

友情链接申请