Java多线程——线程八锁案例分析
Java多线程——线程八锁案例分析
摘要:本文主要学习了多线程并发中的一些案例。
部分内容来自以下博客:
https://blog.csdn.net/dyt443733328/article/details/80019352
多线程的八个案例
通过分析代码,推测打印结果,并运行代码进行验证。
1)两个线程调用同一个对象的两个同步方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number number = new Number(); 4 5 new Thread(new Runnable() { 6 @Override 7 public void run() { 8 number.getOne(); 9 } 10 }).start(); 11 12 new Thread(new Runnable() { 13 @Override 14 public void run() { 15 number.getTwo(); 16 } 17 }).start(); 18 } 19 } 20 21 class Number { 22 public synchronized void getOne() { 23 System.out.println("one"); 24 } 25 26 public synchronized void getTwo() { 27 System.out.println("two"); 28 } 29 }
运行结果如下:
1 one 2 two
结果分析:
被synchronized修饰的方法,锁的对象是方法的调用者。因为两个方法的调用者是同一个,所以两个方法用的是同一个锁,先调用方法的先执行。
2)新增Thread.sleep()给某个方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number number = new Number(); 4 5 new Thread(new Runnable() { 6 @Override 7 public void run() { 8 number.getOne(); 9 } 10 }).start(); 11 12 new Thread(new Runnable() { 13 @Override 14 public void run() { 15 number.getTwo(); 16 } 17 }).start(); 18 } 19 } 20 21 class Number { 22 public synchronized void getOne() { 23 try { 24 Thread.sleep(1000); 25 } catch (InterruptedException e) { 26 e.printStackTrace(); 27 } 28 System.out.println("one"); 29 } 30 31 public synchronized void getTwo() { 32 System.out.println("two"); 33 } 34 }
运行结果如下:
1 // 等待一秒。 2 one 3 two
结果说明:
被synchronized修饰的方法,锁的对象是方法的调用者。因为两个方法的调用者是同一个,所以两个方法用的是同一个锁,先调用方法的先执行,第二个方法只有在第一个方法执行完释放锁之后才能执行。
3)新增一个线程调用新增的一个普通方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number number = new Number(); 4 5 new Thread(new Runnable() { 6 @Override 7 public void run() { 8 number.getOne(); 9 } 10 }).start(); 11 12 new Thread(new Runnable() { 13 @Override 14 public void run() { 15 number.getTwo(); 16 } 17 }).start(); 18 19 new Thread(new Runnable() { 20 @Override 21 public void run() { 22 number.getThree(); 23 } 24 }).start(); 25 } 26 } 27 28 class Number { 29 public synchronized void getOne() { 30 try { 31 Thread.sleep(1000); 32 } catch (InterruptedException e) { 33 e.printStackTrace(); 34 } 35 System.out.println("one"); 36 } 37 38 public synchronized void getTwo() { 39 System.out.println("two"); 40 } 41 42 public void getThree() { 43 System.out.println("three"); 44 } 45 }
运行结果如下:
1 three 2 // 等待一秒。 3 one 4 two
结果说明:
新增的方法没有被synchronized修饰,不是同步方法,不受锁的影响,所以不需要等待。其他线程共用了一把锁,所以还需要等待。
4)两个线程调用两个对象的同步方法,其中一个方法有Thread.sleep()
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number numberOne = new Number(); 4 Number numberTwo = new Number(); 5 6 new Thread(new Runnable() { 7 @Override 8 public void run() { 9 numberOne.getOne(); 10 } 11 }).start(); 12 13 new Thread(new Runnable() { 14 @Override 15 public void run() { 16 numberTwo.getTwo(); 17 } 18 }).start(); 19 } 20 } 21 22 class Number { 23 public synchronized void getOne() { 24 try { 25 Thread.sleep(1000); 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 System.out.println("one"); 30 } 31 32 public synchronized void getTwo() { 33 System.out.println("two"); 34 } 35 }
运行结果如下:
1 two 2 // 等待一秒。 3 one
结果说明:
被synchronized修饰的方法,锁的对象是方法的调用者。因为用了两个对象调用各自的方法,所以两个方法的调用者不是同一个,所以两个方法用的不是同一个锁,后调用的方法不需要等待先调用的方法。
5)将有Thread.sleep()的方法设置为static方法,并且让两个线程用同一个对象调用两个方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number number = new Number(); 4 5 new Thread(new Runnable() { 6 @Override 7 public void run() { 8 number.getOne(); 9 } 10 }).start(); 11 12 new Thread(new Runnable() { 13 @Override 14 public void run() { 15 number.getTwo(); 16 } 17 }).start(); 18 } 19 } 20 21 class Number { 22 public static synchronized void getOne() { 23 try { 24 Thread.sleep(1000); 25 } catch (InterruptedException e) { 26 e.printStackTrace(); 27 } 28 System.out.println("one"); 29 } 30 31 public synchronized void getTwo() { 32 System.out.println("two"); 33 } 34 }
运行结果如下:
1 two 2 // 等待一秒。 3 one
结果说明:
被synchronized和static修饰的方法,锁的对象是类的class对象。仅仅被synchronized修饰的方法,锁的对象是方法的调用者。因为两个方法锁的对象不是同一个,所以两个方法用的不是同一个锁,后调用的方法不需要等待先调用的方法。
6)将两个方法均设置为static方法,并且让两个线程用同一个对象调用两个方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number number = new Number(); 4 5 new Thread(new Runnable() { 6 @Override 7 public void run() { 8 number.getOne(); 9 } 10 }).start(); 11 12 new Thread(new Runnable() { 13 @Override 14 public void run() { 15 number.getTwo(); 16 } 17 }).start(); 18 } 19 } 20 21 class Number { 22 public static synchronized void getOne() { 23 try { 24 Thread.sleep(1000); 25 } catch (InterruptedException e) { 26 e.printStackTrace(); 27 } 28 System.out.println("one"); 29 } 30 31 public static synchronized void getTwo() { 32 System.out.println("two"); 33 } 34 }
运行结果如下:
1 // 等待一秒。 2 one 3 two
结果说明:
被synchronized和static修饰的方法,锁的对象是类的class对象。因为两个同步方法都被static修饰了,所以两个方法用的是同一个锁,后调用的方法需要等待先调用的方法。
7)将两个方法中有Thread.sleep()的方法设置为static方法,另一个方法去掉static修饰,让两个线程用两个对象调用两个方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number numberOne = new Number(); 4 Number numberTwo = new Number(); 5 6 new Thread(new Runnable() { 7 @Override 8 public void run() { 9 numberOne.getOne(); 10 } 11 }).start(); 12 13 new Thread(new Runnable() { 14 @Override 15 public void run() { 16 numberTwo.getTwo(); 17 } 18 }).start(); 19 } 20 } 21 22 class Number { 23 public static synchronized void getOne() { 24 try { 25 Thread.sleep(1000); 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 System.out.println("one"); 30 } 31 32 public synchronized void getTwo() { 33 System.out.println("two"); 34 } 35 }
运行结果如下:
1 two 2 // 等待一秒。 3 one
结果说明:
被synchronized和static修饰的方法,锁的对象是类的class对象。仅仅被synchronized修饰的方法,锁的对象是方法的调用者。即便是用同一个对象调用两个方法,锁的对象也不是同一个,所以两个方法用的不是同一个锁,后调用的方法不需要等待先调用的方法。
8)将两个方法均设置为static方法,并且让两个线程用同一个对象调用两个方法
代码如下:
1 public class Demo { 2 public static void main(String[] args) { 3 Number numberOne = new Number(); 4 Number numberTwo = new Number(); 5 6 new Thread(new Runnable() { 7 @Override 8 public void run() { 9 numberOne.getOne(); 10 } 11 }).start(); 12 13 new Thread(new Runnable() { 14 @Override 15 public void run() { 16 numberTwo.getTwo(); 17 } 18 }).start(); 19 } 20 } 21 22 class Number { 23 public static synchronized void getOne() { 24 try { 25 Thread.sleep(1000); 26 } catch (InterruptedException e) { 27 e.printStackTrace(); 28 } 29 System.out.println("one"); 30 } 31 32 public static synchronized void getTwo() { 33 System.out.println("two"); 34 } 35 }
运行结果如下:
1 // 等待一秒。 2 one 3 two
结果说明:
被synchronized和static修饰的方法,锁的对象是类的class对象。因为两个同步方法都被static修饰了,即便用了两个不同的对象调用方法,两个方法用的还是同一个锁,后调用的方法需要等待先调用的方法。
原文地址:https://www.cnblogs.com/shamao/p/11045282.html
- 数据结构05 栈
- Mybatis【配置文件】
- Java 非线程安全的HashMap如何在多线程中使用
- Java基础-12(02)总结Scanner,String
- MySQL和Oracle对比学习之数据字典元数据(r4笔记第33天)
- Java中ArrayList与LinkedList的区别
- Mybatis【关联映射】
- Java中String、StringBuffer、StringBuilder的区别
- 一条全表扫描sql语句的分析 (r4笔记第32天)
- Mybatis【缓存、代理、逆向工程】
- 关于db_files和maxdatafiles的问题(r4笔记第31天)
- 了解一下CPU 第一篇(r4笔记第30天)
- Java中的String类能否被继承?为什么?
- Mybatis【与Spring整合】
- java教程
- Java快速入门
- Java 开发环境配置
- Java基本语法
- Java 对象和类
- Java 基本数据类型
- Java 变量类型
- Java 修饰符
- Java 运算符
- Java 循环结构
- Java 分支结构
- Java Number类
- Java Character类
- Java String类
- Java StringBuffer和StringBuilder类
- Java 数组
- Java 日期时间
- Java 正则表达式
- Java 方法
- Java 流(Stream)、文件(File)和IO
- Java 异常处理
- Java 继承
- Java 重写(Override)与重载(Overload)
- Java 多态
- Java 抽象类
- Java 封装
- Java 接口
- Java 包(package)
- Java 数据结构
- Java 集合框架
- Java 泛型
- Java 序列化
- Java 网络编程
- Java 发送邮件
- Java 多线程编程
- Java Applet基础
- Java 文档注释