AI 助理
备案控制台
开发者社区 云计算 文章 正文

10.JUC线程高级-线程八锁

2018-09-05 1424
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 所谓线程八锁实际上对应于是否加上synchronized，是否加上static等8种常见情况，代码如下:1.两个普通同步方法，两个线程，标准打印，结果：one twopublic class TestThread8Monitor { pub...

所谓线程八锁实际上对应于是否加上synchronized，是否加上static等8种常见情况，代码如下:

1.两个普通同步方法，两个线程，标准打印，结果：one two

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getTwo();
            }
        }).start();
    }
}
class Number{
    public synchronized void getOne(){
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("Two");
    }
}

2.新增Thread.sleep()给getOne(),结果：one two

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getTwo();
            }
        }).start();
    }
}
class Number{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("Two");
    }
}

3.新增普通方法getThree(),结果：three one two

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getTwo();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number.getThree();
            }
        }).start();
    }
}
class Number{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("Two");
    }
    public void getThree(){
        System.out.println("Three");
    }
}

4.两个普通同步方法，两个对象，结果：two one

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number1 = new Number();
        final Number number2 = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number1.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number2.getTwo();
            }
        }).start();
        
    }
}
class Number{
    public synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("Two");
    }
}

5.修改getOne()为静态同步方法，结果：two one

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number1 = new Number();
        final Number number2 = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number1.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number2.getTwo();
            }
        }).start();
        
    }
}
class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public synchronized void getTwo(){
        System.out.println("Two");
    }
}

6.修改两个方法均为静态同步方法，一个对象，结果：one two

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number1 = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number1.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number1.getTwo();
            }
        }).start();
        
    }
}
class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public static synchronized void getTwo(){
        System.out.println("Two");
    }
}

7.一个静态同步方法，一个非静态同步方法，两个对象，结果：two one

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number1 = new Number();
        final Number number2 = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number1.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number2.getTwo();
            }
        }).start();
        
    }
}
class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public  synchronized void getTwo(){
        System.out.println("Two");
    }
}

8.两个静态同步方法，两个对象，结果：one two

public class TestThread8Monitor {
    public static void main(String[] args) {
        final Number number1 = new Number();
        final Number number2 = new Number();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                number1.getOne();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                number2.getTwo();
            }
        }).start();
        
    }
}
class Number{
    public static synchronized void getOne(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("one");
    }
    public static synchronized void getTwo(){
        System.out.println("Two");
    }
}

以上就是线程的八种常见的情况，线程八锁的关键在于：

非静态方法的锁默认为this，静态方法的锁为对应的class实例（这里是Number.class）
某一个时刻内，只能有一个线程持有锁，无论有几个方法。

总结：

①一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其他的线程都只能等待，换句话说，某一时刻内，只能有唯一一个线程去访问这些synchronized方法。

②锁的是当前对象this，被锁定后，其他线程都不能进入到当前对象的其他的synchronized方法。

③加个普通方法后发现和同步锁无关。

④换成静态同步方法后，情况又变化

⑤所有的非静态同步方法用的都是同一把锁 -- 实例对象本身，也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已经取锁的非静态同步方法释放锁就可以获取他们自己的锁。

⑥所有的静态同步方法用的也是同一把锁 -- 类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非静态同步方法之间不会有竞争条件。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同步方法之间，只要它们是同一个实例对象

关键词：
线程锁
juc线程
线程八锁
线程高级
潘天涯
目录
相关文章
2的n次方_
|
3月前
|
安全 Java 编译器
线程安全问题和锁
本文详细介绍了线程的状态及其转换，包括新建、就绪、等待、超时等待、阻塞和终止状态，并通过示例说明了各状态的特点。接着，文章深入探讨了线程安全问题，分析了多线程环境下变量修改引发的数据异常，并通过使用 `synchronized` 关键字和 `volatile` 解决内存可见性问题。最后，文章讲解了锁的概念，包括同步代码块、同步方法以及 `Lock` 接口，并讨论了死锁现象及其产生的原因与解决方案。
2的n次方_
92 10
线程安全问题和锁
yuanzhengme
|
3月前
|
安全 Java 调度
Java编程时多线程操作单核服务器可以不加锁吗？
Java编程时多线程操作单核服务器可以不加锁吗？
yuanzhengme
50 2
左诗右码
|
25天前
|
供应链 安全 NoSQL
PHP 互斥锁：如何确保代码的线程安全？
在多线程和高并发环境中，确保代码段互斥执行至关重要。本文介绍了 PHP 互斥锁库 `wise-locksmith`，它提供多种锁机制（如文件锁、分布式锁等），有效解决线程安全问题，特别适用于电商平台库存管理等场景。通过 Composer 安装后，开发者可以利用该库确保在高并发下数据的一致性和安全性。
左诗右码
36 6
程序员小海绵
|
3月前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇（2023版）
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合？ConcurrentHashMap、JUC
程序员小海绵
99 3
【Java面试题汇总】多线程、JUC、锁篇（2023版）
椰椰椰耶
|
2月前
|
Java C++
【多线程】JUC的常见类，Callable接口，ReentranLock，Semaphore，CountDownLatch
【多线程】JUC的常见类，Callable接口，ReentranLock，Semaphore，CountDownLatch
椰椰椰耶
36 0
古明地盆
|
2月前
|
运维 API 计算机视觉
深度解密协程锁、信号量以及线程锁的实现原理
深度解密协程锁、信号量以及线程锁的实现原理
古明地盆
48 2
2的n次方_
|
3月前
|
监控 Java 调度
【Java学习】多线程&JUC万字超详解
本文详细介绍了多线程的概念和三种实现方式，还有一些常见的成员方法，CPU的调动方式，多线程的生命周期，还有线程安全问题，锁和死锁的概念，以及等待唤醒机制，阻塞队列，多线程的六种状态，线程池等
2的n次方_
195 6
【Java学习】多线程&JUC万字超详解
javaedge
|
2月前
|
Java 应用服务中间件 测试技术
Java21虚拟线程：我的锁去哪儿了？
【10月更文挑战第8天】
javaedge
46 0
奔跑的数据
|
4月前
|
数据采集 存储 安全
如何确保Python Queue的线程和进程安全性：使用锁的技巧
本文探讨了在Python爬虫技术中使用锁来保障Queue（队列）的线程和进程安全性。通过分析`queue.Queue`及`multiprocessing.Queue`的基本线程与进程安全特性，文章指出在特定场景下使用锁的重要性。文中还提供了一个综合示例，该示例利用亿牛云爬虫代理服务、多线程技术和锁机制，实现了高效且安全的网页数据采集流程。示例涵盖了代理IP、User-Agent和Cookie的设置，以及如何使用BeautifulSoup解析HTML内容并将其保存为文档。通过这种方式，不仅提高了数据采集效率，还有效避免了并发环境下的数据竞争问题。
奔跑的数据
76 1
如何确保Python Queue的线程和进程安全性：使用锁的技巧
Codelinghu
|
2月前
|
安全 调度 数据安全/隐私保护
iOS线程锁
iOS线程锁
Codelinghu
31 0