备案控制台
探索云世界
开发者社区 云计算 文章 正文

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

2018-09-05 1345
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 所谓线程八锁实际上对应于是否加上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线程
线程高级
线程八锁
潘天涯
目录
相关文章
大花爱编程
|
1月前
|
安全 编译器 C#
C#学习相关系列之多线程---lock线程锁的用法
C#学习相关系列之多线程---lock线程锁的用法
大花爱编程
22 1
爱吃糖的范同学
|
3月前
|
存储 Java 数据安全/隐私保护
【JUC】ThreadLocal 如何实现数据的线程隔离？
【1月更文挑战第15天】【JUC】ThreadLocal 如何实现数据的线程隔离？ThreadLocal 导致内存泄漏问题？
爱吃糖的范同学
19 0
东方睿赢
|
2月前
|
安全 Java C++
解释Python中的全局解释器锁（GIL）和线程安全的概念。
解释Python中的全局解释器锁（GIL）和线程安全的概念。
东方睿赢
26 0
童小纯
|
3月前
|
数据处理
多线程与并发编程【线程对象锁、死锁及解决方案、线程并发协作、生产者与消费者模式】(四)-全面详解（学习总结---从入门到深化）
多线程与并发编程【线程对象锁、死锁及解决方案、线程并发协作、生产者与消费者模式】(四)-全面详解（学习总结---从入门到深化）
童小纯
42 1
hsfxuebao
|
1月前
|
存储 安全 Java
并发编程知识点（volatile、JMM、锁、CAS、阻塞队列、线程池、死锁）
并发编程知识点（volatile、JMM、锁、CAS、阻塞队列、线程池、死锁）
hsfxuebao
71 3
桃李春风一杯酒
|
1天前
|
安全 Java 调度
Java并发编程：深入理解线程与锁
【4月更文挑战第18天】本文探讨了Java中的线程和锁机制，包括线程的创建（通过Thread类、Runnable接口或Callable/Future）及其生命周期。Java提供多种锁机制，如`synchronized`关键字、ReentrantLock和ReadWriteLock，以确保并发访问共享资源的安全。此外，文章还介绍了高级并发工具，如Semaphore（控制并发线程数）、CountDownLatch（线程间等待）和CyclicBarrier（同步多个线程）。掌握这些知识对于编写高效、正确的并发程序至关重要。
桃李春风一杯酒
11 4
请看我回答~
|
5天前
|
Java 程序员 编译器
Java中的线程同步与锁优化策略
【4月更文挑战第14天】在多线程编程中，线程同步是确保数据一致性和程序正确性的关键。Java提供了多种机制来实现线程同步，其中最常用的是synchronized关键字和Lock接口。本文将深入探讨Java中的线程同步问题，并分析如何通过锁优化策略提高程序性能。我们将首先介绍线程同步的基本概念，然后详细讨论synchronized和Lock的使用及优缺点，最后探讨一些锁优化技巧，如锁粗化、锁消除和读写锁等。
请看我回答~
16 7
历年考试不作弊
|
13天前
|
安全 Java 调度
深入理解Java中的线程安全与锁机制
【4月更文挑战第6天】 在并发编程领域，Java语言提供了强大的线程支持和同步机制来确保多线程环境下的数据一致性和线程安全性。本文将深入探讨Java中线程安全的概念、常见的线程安全问题以及如何使用不同的锁机制来解决这些问题。我们将从基本的synchronized关键字开始，到显式锁（如ReentrantLock），再到读写锁（ReadWriteLock）的讨论，并结合实例代码来展示它们在实际开发中的应用。通过本文，读者不仅能够理解线程安全的重要性，还能掌握如何有效地在Java中应用各种锁机制以保障程序的稳定运行。
历年考试不作弊
16 4
泡沫o0
|
1月前
|
Linux API C++
【Linux C/C++ 线程同步 】Linux API 读写锁的编程使用
【Linux C/C++ 线程同步 】Linux API 读写锁的编程使用
泡沫o0
19 1
技术混子
|
1月前
|
安全 Java 开发者
Java中的并发编程：探索线程安全与锁机制
【2月更文挑战第12天】 本文深入探讨Java并发编程的核心概念，特别是线程安全和锁机制。不同于传统的技术文章摘要，我们将通过一个实际案例来展开讨论，即如何在多线程环境下保证数据的一致性和完整性。我们将从基础的线程概念入手，逐步深入到synchronized关键字、显式锁（如ReentrantLock），以及其他并发工具类（如CountDownLatch、CyclicBarrier等）的应用。通过本文，读者不仅能够掌握Java并发编程的理论知识，还能了解到如何在实际开发中合理地应用这些并发机制，以提升应用程序的性能和稳定性。
技术混子
17 2

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    QML多线程魔法：探索不同方法，提升性能
  • 3
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
  • 4
    【C/C++ 单线程性能分析工具 Gprof】 GNU的C/C++ 性能分析工具 Gprof 使用全面指南
  • 5
    【C++ 线程】深入理解C++线程管理：从对象生命周期到线程安全
  • 6
    【Qt 线程】探索Qt线程编程的奥秘：多角度深入剖析（一）
  • 7
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
  • 8
    【软件设计师备考 专题 】操作系统的内核（中断控制）、进程、线程概念
  • 9
    【Linux 进程/线程状态 】深入理解Linux C++中的进程/线程状态：阻塞，休眠，僵死
  • 10
    C++线程 并发编程：std::thread、std::sync与std::packaged_task深度解析（二）
  • 1
    【java进阶】Java中线程的实现方式
    13
  • 2
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    103
  • 3
    【C++】—— C++11之线程库
    35
  • 4
    C/C++ 线程超详细讲解（系统性学习day10）
    30
  • 5
    Swing通过后台线程实现页面更新
    20
  • 6
    Java中的线程安全集合
    29
  • 7
    什么是多任务和线程？用线程写的一个udp同步聊天器
    30
  • 8
    多线程------Future异步任务
    22
  • 9
    在多线程中sleep()和wait()的区别（详细）
    53
  • 10
    深入解析线程安全的Hashtable实现
    78

    • 相关电子书

    更多
  • 多IO线程优化版
  • 多线程
  • 原子变量与内存模型
    • 下一篇
    阿里云oss简介和使用流程
    为什么选择阿里云什么是云计算全球基础设施技术领先稳定可靠安全合规分析师报告
    产品和定价全部产品免费试用产品动态产品定价价格计算器云上成本管理
    解决方案技术解决方案
    文档与社区文档开发者社区天池大赛培训与认证
    权益中心免费试用高校计划企业扶持计划推荐返现计划
    支持与服务基础服务企业增值服务迁云服务官网公告健康看板信任中心
    关注阿里云
    关注阿里云公众号或下载阿里云APP，关注云资讯，随时随地运维管控云服务
    阿里云APP阿里云微信
    联系我们：4008013260
    法律声明Cookies政策廉正举报安全举报联系我们加入我们
    阿里巴巴集团淘宝网天猫全球速卖通阿里巴巴国际交易市场1688阿里妈妈飞猪阿里云计算AliOS万网高德UC友盟优酷钉钉支付宝达摩院淘宝海外阿里云盘饿了么
    © 2009-2024 Aliyun.com 版权所有 增值电信业务经营许可证： 浙B2-20080101 域名注册服务机构许可： 浙D3-20210002 京D3-20220015
    浙公网安备 33010602009975号浙B2-20080101-4