JAVA之旅(十三)——线程的安全性,synchronized关键字,多线程同步代码块,同步函数,同步函数的锁是this
JAVA之旅(十三)——线程的安全性,synchronized关键字,多线程同步代码块,同步函数,同步函数的锁是this
一.线程的安全性
当我们开启四个窗口(线程)把票陆陆续续的卖完了之后,我们要反思一下,这里面有没有安全隐患呢?在实际情况中,这种事情我们是必须要去考虑安全问题的,那我们模拟一下错误
package com.lgl.hellojava; import javax.security.auth.callback.TextInputCallback; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 需求:简单的卖票程序,多个线程同时卖票 */ MyThread myThread = new MyThread(); Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); Thread t3 = new Thread(myThread); Thread t4 = new Thread(myThread); t1.start(); t2.start(); t3.start(); t4.start(); } } /** * 卖票程序 * * @author LGL * */ class MyThread implements Runnable { // 票数 private int tick = 100; @Override public void run() { while (true) { if (tick > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("卖票:" + tick--); } } } }
我们输出的结果
这里出现了0票,如果你继续跟踪的话,你会发现,还会出现-1,-2之类的票,这就是安全隐患,那原因是什么呢?
- 当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一个部分,还没有执行完,另外一个线程参与了执行,导致共享数据的错误
解决办法:对多条操作共享数据的语句,只能让一个线程都执行完再执行过程中其他线程不可以参与运行
JAVA对多线程的安全问题提供了专业的解决办法,就是同步代码块
synchronized(对象){ //需要同步的代码 }
那我们怎么用呢?
package com.lgl.hellojava; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 需求:简单的卖票程序,多个线程同时卖票 */ MyThread myThread = new MyThread(); Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); Thread t3 = new Thread(myThread); Thread t4 = new Thread(myThread); t1.start(); t2.start(); t3.start(); t4.start(); } } /** * 卖票程序 * * @author LGL * */ class MyThread implements Runnable { // 票数 private int tick = 100; Object oj = new Object(); @Override public void run() { while (true) { synchronized(oj){ if (tick > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("卖票:" + tick--); } } } } }
这样,就输出
二.多线程同步代码块
我们为什么可以这样去同步线程?
对象如同锁,持有锁的线程可以在同步中执行,没有执行锁的线程即使获取了CPU的执行权,也进不去,因为没有获取锁,我们可以这样理解
- 四个线程,哪一个进去就开始执行,其他的拿不到执行权,所以即使拿到了执行权,也进不去,这个同步能解决线程的安全问题
但是,同步是有前提的
- 1.必须要有两个或者两个以上的线程,不然你同步也没必要呀
- 2.必须是多个线程使用同一锁
必须保证同步中只能有一个线程在运行
但是他也有一个弊端:那就是多个线程都需要判断锁,较为消耗资源
三.多线成同步函数
我们可以写一段小程序,来验证这个线程同步的问题,也就是说我们看看下面这段程序是否有安全问题,有的话,如何解决?
package com.lgl.hellojava; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 需求:银行里有一个金库 有两个人要存钱300 */ MyThread myThread = new MyThread(); Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); t1.start(); t2.start(); } } /** * 存钱程序,一次100 * @author LGL * */ class MyThread implements Runnable { private Bank b = new Bank(); @Override public void run() { for (int i = 0; i < 3; i++) { b.add(100); } } } /** * 银行 * @author LGL * */ class Bank { private int sum; public void add(int n) { sum = sum + n; System.out.println("sum:" + sum); } }
当你执行的时候你会发现
这里是没错的,存了600块钱,但是,这个程序是有安全隐患的
如何找到问题?
- 1.明确哪些代码是多线成运行代码
- 2.明确共享数据
- 3.明确多线成运行代码中哪些语句是操作共享数据的
那我们怎么找到安全隐患呢?我们去银行的类里面做些认为操作
/** * 银行 * @author LGL * */ class Bank { private int sum; public void add(int n) { sum = sum + n; try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("sum:" + sum); } }
让他sleep一下你就会发现
这样的话,我们就可以使用我们的同步代码了
/** * 银行 * * @author LGL * */ class Bank { private int sum; Object j = new Object(); public void add(int n) { synchronized (j) { sum = sum + n; try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("sum:" + sum); } } }
这样代码就可以同步了
哪些代码该同步,哪些不该同步,你一定要搞清楚,根据上面的3个条件
大家有没有注意到,函数式具有封装代码的特定,而我们所操作的同步代码块也是有封装代码的特性,拿这样的话我们就可以换一种形式去操作,那就是写成函数的修饰符
/** * 银行 * * @author LGL * */ class Bank { private int sum; public synchronized void add(int n) { sum = sum + n; try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println("sum:" + sum); } }
这样也是OK的
四.同步函数的锁是this
既然我们学习了另一种同步函数的写法,那我们就可以把刚才的买票小例子进一步封装一下了
package com.lgl.hellojava; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 需求:简单的卖票程序,多个线程同时卖票 */ MyThread myThread = new MyThread(); Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); Thread t3 = new Thread(myThread); Thread t4 = new Thread(myThread); t1.start(); t2.start(); t3.start(); t4.start(); } } /** * 卖票程序 * * @author LGL * */ class MyThread implements Runnable { // 票数 private int tick = 100; @Override public synchronized void run() { while (true) { if (tick > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread()+"卖票:" + tick--); } } } }
但是这样做,你却会发现一个很严重的问题,那就是
永远只有0线程在执行卖票
那是因为我们并没有搞清楚需要同步哪一个代码段,我们应该执行的只是里面的那两段代码,而不是整个死循环,所以我们得封装个函数进行线程同步
package com.lgl.hellojava; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 需求:简单的卖票程序,多个线程同时卖票 */ MyThread myThread = new MyThread(); Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); Thread t3 = new Thread(myThread); Thread t4 = new Thread(myThread); t1.start(); t2.start(); t3.start(); t4.start(); } } /** * 卖票程序 * * @author LGL * */ class MyThread implements Runnable { // 票数 private int tick = 100; @Override public void run() { while (true) { show(); } } private synchronized void show() { if (tick > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread() + "卖票:" + tick--); } } }
这样输出解决了
问题是被解决了,但是随之问题也就来了
- 同步函数用的是哪一个锁呢?
函数需要被对象调用,那么函数都有一个所属对象的引用,就是this,所以同步函数所引用的锁是this,我们来验证一下,我们把程序改动一下
使用两个线程来卖票,一个线程在同步代码块中,一个线程在同步函数中,都在执行卖票动作
package com.lgl.hellojava; //公共的 类 类名 public class HelloJJAVA { public static void main(String[] args) { /** * 需求:简单的卖票程序,多个线程同时卖票 */ MyThread myThread = new MyThread(); Thread t1 = new Thread(myThread); Thread t2 = new Thread(myThread); // Thread t3 = new Thread(myThread); // Thread t4 = new Thread(myThread); t1.start(); myThread.flag = false; t2.start(); // t3.start(); // t4.start(); } } /** * 卖票程序 * * @author LGL * */ class MyThread implements Runnable { // 票数 private int tick = 100; Object j = new Object(); boolean flag = true; @Override public void run() { if (flag) { while (true) { synchronized (j) { if (tick > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread() + "code:" + tick--); } } } } else { while (true) { show(); } } } private synchronized void show() { if (tick > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread() + "show:" + tick--); } } }
当我们运行的时候就发现
他只在show中进行,那是为什么呢?因为主线程开启的时候瞬间执行,我们要修改一下,让线程1开启的时候,主线程睡个10毫秒试试
t1.start(); try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } myThread.flag = false; t2.start();
这样输出的结果貌似是交替进行
但是所知而来的,是0票,这说明这个线程不安全,我们明明加了同步啊,怎么还是不安全呢?因为他用的不是同一个锁,一个用Object,一个是用this的锁,我们再改动一下,我们把Object更好为this,这样输出
现在就安全,也正确了
好的,我们本篇幅就先到这里了,我们下篇也继续讲线程
低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。
持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。
转载内容版权归作者及来源网站所有,本站原创内容转载请注明来源。
- 上一篇
JAVA之旅(十二)——Thread,run和start的特点,线程运行状态,获取线程对象和名称,多线程实例演示,使用Runnable接口
JAVA之旅(十二)——Thread,run和start的特点,线程运行状态,获取线程对象和名称,多线程实例演示,使用Runnable接口 一.Thread 如何在自定义的代码中,自定义一个线程呢? 我们查看API文档,我们要启动一个线程,先实现一个子类, package com.lgl.hellojava; public class MyThread extends Thread { @Override public void run() { System.out.println("我是一个线程"); } } 我们要调用它的话,只需要start就可以 MyThread thread = new MyThread(); thread.start(); 这样就会执行我们的run方法 我们来理一下思路,线程有两种创建方式,我们先将第一种: 1.继承Thread 类 2.复写Thread类的run方法 3.调用线程的start方法 该方法有两个作用,启动线程和调用run方法 我们可以把代码改一下 package com.lgl.hellojava; //公共的 类 类名 public cla...
- 下一篇
JAVA之旅(十四)——静态同步函数的锁是class对象,多线程的单例设计模式,死锁,线程中的通讯以及通讯所带来的安全隐患,等待唤醒机制
JAVA之旅(十四)——静态同步函数的锁是class对象,多线程的单例设计模式,死锁,线程中的通讯以及通讯所带来的安全隐患,等待唤醒机制 一.静态同步函数的锁是class对象 我们在上节验证了同步函数的锁是this,但是对于静态同步函数,你又知道多少呢? 我们做一个这样的小实验,我们给show方法加上static关键字去修饰 private static synchronized void show() { if (tick > 0) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread() + "show:" + tick--); } } 然后我们来打印一下 发现他打印出0票了,说明他还是存在this隐患,同时也说明了一点就是他使用的锁不是this,那既然不是this,那是什么呢? 因为静态方法中,不可以定义this,...
相关文章
文章评论
共有0条评论来说两句吧...
文章二维码
点击排行
推荐阅读
最新文章
- CentOS8安装MyCat,轻松搞定数据库的读写分离、垂直分库、水平分库
- Mario游戏-低调大师作品
- Docker安装Oracle12C,快速搭建Oracle学习环境
- Red5直播服务器,属于Java语言的直播服务器
- CentOS7,CentOS8安装Elasticsearch6.8.6
- CentOS8编译安装MySQL8.0.19
- SpringBoot2整合MyBatis,连接MySql数据库做增删改查操作
- Springboot2将连接池hikari替换为druid,体验最强大的数据库连接池
- CentOS6,CentOS7官方镜像安装Oracle11G
- Jdk安装(Linux,MacOS,Windows),包含三大操作系统的最全安装