首页 / JAVA / java多线程——多线程的安全问题
java多线程——多线程的安全问题
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了java多线程——多线程的安全问题，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含6677字，纯文字阅读大概需要10分钟。
内容图文
java多线程——多线程的安全问题
模拟火车票售票程序：
1 /**
2 * 售票案例：售票的动作被多个线程同时执行
3 */
4 class Ticket implements Runnable{
5 //描述票的数量
6 private int tickets=100;
7 //售票,线程任务中通常都有循环结构
8 @Override
9 public void run() {
10 while(true) {
11 if(tickets>0) {//此处可能线程1,2,3,4都进入，那么就可能出现输出tickets为负值的错误数据
12 try {
13 Thread.sleep(200);
14 } catch (InterruptedException e) {
15 //待处理
16 }
17 System.out.println(Thread.currentThread().getName()+"------"+tickets--);
18 }
19 }
20 }
21 }
22
23 public class TicketSellDemo {
24 public static void main(String[] args) {
25 Ticket t=new Ticket();
26
27 Thread t1=new Thread(t);
28 Thread t2=new Thread(t);
29 Thread t3=new Thread(t);
30 Thread t4=new Thread(t);
31
32 t1.start();
33 t2.start();
34 t3.start();
35 t4.start();
36 }
37 }
1、线程安全问题出现的原因：
（1）多个线程操作共享的数据；
（2）线程任务操作共享数据的代码有多条（多个运算）。
2、解决思路：
只要让一个线程在执行线程任务时将多条操作共享数据的代码执行完，在执行过程中，不要让其他线程参与运算。那么如何在代码中体现呢？java中解决此问题：
（1）通过代码块完成，这个代码块叫做同步代码块，使用关键字synchronized。
1 /**
2 * 售票案例：售票的动作被多个线程同时执行
3 */
4 class Ticket implements Runnable{
5 //描述票的数量
6 private int tickets=20;
7 //售票,线程任务中通常有循环结构
8 private Object obj=new Object();//用来处理安全问题
9 @Override
10 public void run() {
11 while(true) {
12 synchronized(obj)
13 {
14 if(tickets>0) {
15 try { Thread.sleep(200);} catch (InterruptedException e) {/*待处理*/}
16 System.out.println(Thread.currentThread().getName()+"------"+tickets--);
17 }
18 }
19 }
20 }
21 }
22
23 public class TicketSellDemo {
24 public static void main(String[] args) {
25 Ticket t=new Ticket();
26
27 Thread t1=new Thread(t);
28 Thread t2=new Thread(t);
29 Thread t3=new Thread(t);
30 Thread t4=new Thread(t);
31
32 t1.start();
33 t2.start();
34 t3.start();
35 t4.start();
36 }
37 }
View Code
同步的前提：必须保证多个线程中使用的是同一个锁。例如：若将上述代码中synchronized(obj)改为synchronized(new Object())，安全问题仍然不能解决。
（2）使用同步函数（方法）
同步函数使用的锁是this，静态同步函数使用的锁是字节码文件对象，类名.class.
1 /**
2 * 售票案例：售票的动作被多个线程同时执行
3 */
4 class Ticket implements Runnable{
5 //描述票的数量
6 private int tickets=20;
7 //售票,线程任务中通常有循环结构
8 @Override
9 public void run() {
10 //method1();
11 while(true) {
12 sale();
13 }
14 }
15
16 public synchronized void sale() {
17 if(tickets>0) {
18 // try { Thread.sleep(200);} catch (InterruptedException e) {/*待处理*/}
19 System.out.println(Thread.currentThread().getName()+"------"+tickets--);
20 }
21 }
22 }
23
24 public class TicketSellDemo {
25 public static void main(String[] args) {
26 Ticket t=new Ticket();
27
28 Thread t1=new Thread(t);
29 Thread t2=new Thread(t);
30 Thread t3=new Thread(t);
31 Thread t4=new Thread(t);
32
33 t1.start();
34 t2.start();
35 t3.start();
36 t4.start();
37 }
38 }
View Code
同步函数和同步代码块有什么区别？
同步函数使用的锁是固定的this，同步代码块使用的锁可以是任意对象。当线程任务只需要一个同步时完全可以使用同步函数。当线程任务中需要多个同步时，必须通过锁来区分，这时必须使用同步代码块。同步代码块较为常用。
3、单例懒汉式的并发访问
1 //饿汉式，多线程并发没有问题。
2 /*
3 public class Single {
4 private static final Single instance=new Single();
5 private Single() {};
6 public static Single getInstance() {
7 return instance;
8 }
9 }
10 */
11
12 //懒汉式:存在线程安全问题，需要加上同步机制synchronized
13 /*
14 public class Single {
15 private static Single instance=null;
16 private Single() {}
17 public static synchronized Single getInstance() {
18 if(instance==null) {
19 instance=new Single();
20 }
21 return instance;
22 }
23 }
24 */
25 //但是，同步的出现降低了效率.可以通过双重判断，解决效率问题，减少判断次数
26 public class Single {
27 private static Single instance=null;
28 private Single() {}
29 public static Single getInstance() {
30 if(instance==null) {
31 synchronized(Single.class){
32 if(instance==null) {
33 instance=new Single();
34 }
35 }
36 }
37 return instance;
38 }
39 }
Single
4、死锁
同步的另一个弊端：死锁
情况之一：当线程任务中出现了多个同步（多个锁）时，如果同步中嵌套了其他的同步，这时容易引发死锁。
1 class Test implements Runnable{
2 private boolean flag;
3 Test(boolean flag){
4 this.flag=flag;
5 }
6
7 public void run() {
8 if(flag) {
9 while(true) {//加了循环一定会锁住
10 synchronized(Mylock.lockA) {
11 System.out.println(Thread.currentThread().getName()+"....if...lockA");
12 synchronized(Mylock.lockB) {
13 System.out.println(Thread.currentThread().getName()+"....if...lockB");
14 }
15 }
16 }
17
18 }else {
19 while(true) {
20 synchronized(Mylock.lockB) {
21 System.out.println(Thread.currentThread().getName()+"....else....lockB");
22 synchronized(Mylock.lockA) {
23 System.out.println(Thread.currentThread().getName()+"....else.....lockA");
24 }
25 }
26 }
27 }
28 }
29 }
30
31 class Mylock{
32 public static final Object lockA=new Object();
33 public static final Object lockB=new Object();
34 }
35 public class Deadlocks {
36 public static void main(String[] args) {
37 Test t1=new Test(true);
38 Test t2=new Test(false);
39 Thread t11=new Thread(t1);
40 Thread t22=new Thread(t2);
41 t11.start();
42 t22.start();
43 }
44
45
46 }
Deadlocks
内容总结
以上是互联网集市为您收集整理的java多线程——多线程的安全问题全部内容，希望文章能够帮你解决java多线程——多线程的安全问题所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。