Java Tread多线程（2）多线程安全问题

最新推荐文章于 2024-01-20 20:42:04 发布
原创 最新推荐文章于 2024-01-20 20:42:04 发布 · 2.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文演示，Tread多线程安全问题，以及几种解决多线程安全方式（线程同步）。

1）一个线程不安全的Demo

2）线程同步（synchronized，函数同步，this锁，Class对象锁）


一、小Demo演示引出线程安全问题：

package thread.runable1.qdj;
//1.定义类实现Runnable接口
class RunDemo1 implements Runnable
{
	private int x = 5;
	//2.覆盖Runnable接口中的run方法
	//将线程代码存放在run中
	public void run() 
	{
		while (true)
		{
			if (x > 0)
			{
				//添加sleep()，注意：sleep()会抛出异常
				try {
					Thread.sleep(10);  //让线程睡眠10ms
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("Runnable:"+x);
				--x;
			}
		}
	}
}
public class CRunableDemo1 {

	public static void main(String[] args) {
		RunDemo1 r = new RunDemo1();
		//3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		Thread t3 = new Thread(r);
		Thread t4 = new Thread(r);
		//4.使用start开启线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

运行显示结果：


以上打印出了0，-1，-2等数字，发现没？（线程出问题了吧！！！）
问题：出问题的原因是什么呢？

解释：线程1进入，强制睡眠10ms；此时线程2进入，又强制睡眠10ms；线程3进入又强制睡眠10ms；线程4进入再强制睡眠10ms；

注意，以上4个线程睡眠时都已经进入了if语句，进入的时候x>0还是成立的；

好了，线程1醒来，开始打印打印5,4,3,2，这时候--x还没执行，线程2就醒来了，抢去了cpu的执行权.....................


二、线程同步

问题：对于上面的问题，我们是不是可以采取一个这样的措施？当线程1执行run代码段的时候，我们不让其他的线程来执行，直到线程1执行完，其他的线程才可以进入。

解决方案：好在Java里面本来就有这样的函数，将代码段包裹起来，就可以达到上面问题描述的效果。函数名：synchronized，需要一个参数，随便传个对象就ok了（具体参数区别分析，请往下拉见附录1）。

1）一个简单的解决方案：

package thread.runable1.qdj;
//1.定义类实现Runnable接口
class RunDemo1 implements Runnable
{
	private int x = 5;
	Object obj = new Object();
	//2.覆盖Runnable接口中的run方法
	//将线程代码存放在run中
	public void run() 
	{
		while (true)
		{
			synchronized (obj) 
			{
				if (x > 0)
				{
					//添加sleep()，注意：sleep()会抛出异常
					try {
						Thread.sleep(10);  //让线程睡眠10ms
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println("Runnable:"+x);
					--x;
				}
			}
		}
	}
}
public class CRunableDemo1 {

	public static void main(String[] args) {
		RunDemo1 r = new RunDemo1();
		//3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		Thread t3 = new Thread(r);
		Thread t4 = new Thread(r);
		//4.使用start开启线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
运行结果显示：


2）换一种更简单的解决方法：函数同步（将synchronized直接添加在函数前面）

说明：有没有发现，函数就是对多个语句的打包？但是，函数只是打包，而没有像上面的synchronized一样实现同步。但是有一种方法可以达到这个效果，看下面的小Demo就明白了。

package thread.runable1.qdj;
//同步函数
class SynFunc 
{
	private int x = 5;
	public synchronized void aFunc()
	{
		while (true)
		{
			if (x > 0)
			{
				//添加sleep()，注意：sleep()会抛出异常
				try {
					Thread.sleep(10);  //让线程睡眠10ms
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("Runnable:"+x);
				--x;
			}
		}
	}
}
//1.定义类实现Runnable接口
class RunDemo1 implements Runnable
{
	private SynFunc syn = new SynFunc();
	//2.覆盖Runnable接口中的run方法
	//将线程代码存放在run中
	public void run() 
	{
		syn.aFunc();
	}
}
public class CRunableDemo1 {

	public static void main(String[] args) {
		RunDemo1 r = new RunDemo1();
		//3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		Thread t3 = new Thread(r);
		Thread t4 = new Thread(r);
		//4.使用start开启线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
运行结果显示：（同上）


附录1：对于函数锁中synchronized中的参数的解释分析（我们先看一下下面这个小Demo）

package thread.runable1.qdj;

//1.定义类实现Runnable接口
class RunDemo1 implements Runnable
{
	private int x = 100;
	Object obj = new Object();
	boolean flag = true;
	//2.覆盖Runnable接口中的run方法
	//将线程代码存放在run中
	public void run() 
	{
		if (flag)
		{
			while (true)
			{
				synchronized(obj)
				{
					if (x > 0)
					{
						//添加sleep()，注意：sleep()会抛出异常
						try {
							Thread.sleep(10);  //让线程睡眠10ms
						} catch (Exception e) {
							e.printStackTrace();
						}
						System.out.println("Runnable:"+x);
						--x;
					}
				}
			}
		}
		else 
		{
			while (true)
				aFunc();
		}
	}
	public synchronized void aFunc()
	{
		while (true)
		{
			if (x > 0)
			{
				//添加sleep()，注意：sleep()会抛出异常
				try {
					Thread.sleep(10);  //让线程睡眠10ms
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("Runnable:"+x);
				--x;
			}
		}
	}
}
public class CRunableDemo1 {

	public static void main(String[] args) {
		RunDemo1 r = new RunDemo1();
		//3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		//4.使用start开启线程
		t1.start();
		//添加sleep()，注意：sleep()会抛出异常
		try {
			Thread.sleep(10);  //让线程睡眠10ms
		} catch (Exception e) {
			e.printStackTrace();
		}
		r.flag = false;
		t2.start();
	}
}
运行显示结果：



郁闷吧，又出现线程安全问题了，可是我们分明都加了锁的呀？这是什么原因导致的呢？其实，问题就出在了，synchronized里面的参数上。

函数同步锁定的是this，而上面的小Demo里面，一个是函数同步锁（this），另外一个是obj锁，发现没？解决方案：将obj锁改为this锁就没问题了。

解决后的小Demo：

package thread.runable1.qdj;

//1.定义类实现Runnable接口
class RunDemo1 implements Runnable
{
	private int x = 100;
	Object obj = new Object();
	boolean flag = true;
	//2.覆盖Runnable接口中的run方法
	//将线程代码存放在run中
	public void run() 
	{
		if (flag)
		{
			while (true)
			{
				synchronized(this)
				{
					if (x > 0)
					{
						//添加sleep()，注意：sleep()会抛出异常
						try {
							Thread.sleep(10);  //让线程睡眠10ms
						} catch (Exception e) {
							e.printStackTrace();
						}
						System.out.println("Runnable:"+x);
						--x;
					}
				}
			}
		}
		else 
		{
			while (true)
				aFunc();
		}
	}
	public synchronized void aFunc()
	{
		while (true)
		{
			if (x > 0)
			{
				//添加sleep()，注意：sleep()会抛出异常
				try {
					Thread.sleep(10);  //让线程睡眠10ms
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("Runnable:"+x);
				--x;
			}
		}
	}
}
public class CRunableDemo1 {

	public static void main(String[] args) {
		RunDemo1 r = new RunDemo1();
		//3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		//4.使用start开启线程
		t1.start();
		//添加sleep()，注意：sleep()会抛出异常
		try {
			Thread.sleep(10);  //让线程睡眠10ms
		} catch (Exception e) {
			e.printStackTrace();
		}
		r.flag = false;
		t2.start();
	}
}
运行显示结果：



附录2：提出另外一个问题，既然函数同步锁定的是this，那么如下的这个函数要如何解释？静态函数没有this，如何锁定？

public static synchronized void aFunc()
	{
		while (true)
		{
			if (x > 0)
			{
				//添加sleep()，注意：sleep()会抛出异常
				try {
					Thread.sleep(10);  //让线程睡眠10ms
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("Runnable:"+x);
				--x;
			}
		}
	}
解决方案：静态函数，是类函数由类调用。其实这里static函数的锁是Class对象。下面注意看如下小Demo中synchronized的参数。

解决后的小Demo：

package thread.runable1.qdj;

//1.定义类实现Runnable接口
class RunDemo1 implements Runnable
{
	private static int x = 100;
	boolean flag = true;
	//2.覆盖Runnable接口中的run方法
	//将线程代码存放在run中
	public void run() 
	{
		if (flag)
		{
			while (true)
			{
				synchronized(RunDemo1.class)
				{
					if (x > 0)
					{
						//添加sleep()，注意：sleep()会抛出异常
						try {
							Thread.sleep(10);  //让线程睡眠10ms
						} catch (Exception e) {
							e.printStackTrace();
						}
						System.out.println("Runnable:"+x);
						--x;
					}
				}
			}
		}
		else 
		{
			while (true)
				aFunc();
		}
	}
	public static synchronized void aFunc()
	{
		while (true)
		{
			if (x > 0)
			{
				//添加sleep()，注意：sleep()会抛出异常
				try {
					Thread.sleep(10);  //让线程睡眠10ms
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("Runnable:"+x);
				--x;
			}
		}
	}
}
public class CRunableDemo1 {

	public static void main(String[] args) {
		RunDemo1 r = new RunDemo1();
		//3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		//4.使用start开启线程
		t1.start();
		//添加sleep()，注意：sleep()会抛出异常
		try {
			Thread.sleep(10);  //让线程睡眠10ms
		} catch (Exception e) {
			e.printStackTrace();
		}
		r.flag = false;
		t2.start();
	}
}

运行显示结果：（同上）



qingdujun
关注
Java多线程
m0_62143653的博客
02-19 551
Java
Java之多线程(6个demo)
nuist_NJUPT的博客
08-06 3927
本文主要介绍Java中多线程，在Java中启动多线程的方法包括：继承Thread类或者实现Runnable接口，介绍了设置线程名称，设置线程优先级，设置守护线程等，介绍了线程同步，使用synchronized关键字和lock锁分别实现线程同步，解决线程安全问题，介绍了生产者和消费者模式，涉及线程延迟，等待，唤醒的方法。...
多线程(Thread)
CDZAllier的博客
08-05 1738
程序 ： 是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态概念。 进程： 是程序在处理机上的一次执行过程，它是一个动态的概念。（独立运行的程序，也就是处理机执行的过程） 进程的三种状态： 1)就绪状态(Ready)2)运行状态(Running)3)阻塞状态(Blocked) 线程：（java是多线程） 线程是进程的划分，（也就是进程中的一个执行路径，共享一个空间，...
java测试线程存在_java测试线程不安全简单Demo
weixin_42682754的博客
02-28 268
描述场景初学java的时候,对线程安全和不安全一直都是一个模糊的状态,接下来的这段日志我会继续深入了解多线程,以及线程安全的相关知识,下面我用一个简单的小案例来测试一下多线程场景下导致的不安全问题．＞设计场景:一个学校统计这个学校有多少个学生,我们每创建一个学生,学生就加1,这样我们就用这个计数来统计学校最后有多少学生.- 学生实体类public class Student {private St...
多线程-Thread类及常见方法
最新发布
weixin_71841320的博客
01-20 1428
Thread类是Java编程语言中的一个重要类，用于支持多线程编程。它是java.lang包中的一部分，提供了创建和管理线程的方法和功能。通过使用Thread类，可以同时执行多个任务，实现并行处理。每个线程都有独立的执行路径，可以在不同的时间段内独立运行。这使得程序能够更高效地利用计算机的资源，并提高应用程序的响应速度。Thread类提供了许多方法来管理线程的行为，例如start()方法用于启动线程，join()方法用于等待线程的结束，sleep()方法用于暂停线程的执行等等。
[Java]Java多线程数据安全(同步线程的方法)
祥的专栏
02-05 1674
预备知识Thread.yield():API中解释： 暂停当前正在执行的线程对象，并执行其他线程。 注意：这里的其他也包含当前线程，即，当前线程也能够再次抢占CPU。Thread.sleep(long millis): API解释：使当前线程暂停millis所指定的毫秒，转到执行其它线程。 不使用关键字synchronized(容易出错)Java源代码public class MyRunnable
线程池 线程安全 Java_java 线程安全_多线程_线程池
weixin_36372610的博客
02-13 179
1. 线程安全democode：public class RunnerableImpl implements Runnable {/*** 设置电影票数量* @Author chenpeng* @Description //TODO* @Date 23:57* @Param* @return**/private static int ticket = 100;@Overridepublic voi...
Java多线程Thread
qq_43609524的博客
04-19 1916
Java多线程Thread多线程实现原理线程内存图创建多线程的多种方法自定义Thread子类实现Runnable接口实现Runnable接口创建多线程程序的好处使用匿名内部类线程的方法获取线程的名称设置线程名称线程暂停（睡眠）方法 sleep 多线程实现原理 线程内存图 创建多线程的多种方法 自定义Thread子类 class MyThread extends Thread{ @Override public void run() { for (int i = 0; i
使用多线程的方法来实现龟兔赛跑问题，使用语言：JAVA
Arthur_Altria的博客
03-11 547
使用JAVA创建多线程，并解决龟兔赛跑问题
Java 试试多线程
qq_hua_xia的博客
11-08 638
题目详情： 7-2 试试多线程 (25 分) 编写4个线程，第一个线程从1加到25，第二个线程从26加到50,第三个线程从51加到75，第四个线程从76加到100，最后再把四个线程计算的结果相加。 输入格式: 无 输出格式: 最终结果 输入样例: 结尾无空行 输出样例: 5050 结尾无空行 答案代码： import java.util.*; public class Main { public static void main(String[] args) {
Java多线程 --Thread
十二间记，知不足而奋斗，望远山而前行。千里不辞行路远，时光早晚到天涯。
08-09 504
多线程
java多线程一个简单的例子说明线程安全的情况
qq_45526514的博客
02-25 222
一个简单的例子说明代码中遇到的线程安全的问题
Java多线程demo
懵懂无知的蜗牛的博客
05-23 5142
demo代码如下：package com.test; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * 多线程demo示例 * @since 2018-05-22 * @ve...
多线程Tread中的常用方法
Locus的博客
02-10 570
多线程的方法 Tread中常用的方法 start()：启动当前线程；调用当前线程的run() run()：通常需要重写Thread类中的方法，将创建的线程要执行的操作声明在此方法中 currentThread()：静态方法，返回执行当前代码的线程 getName()：获取当前线程的名字 setName()：设置当前线程的名字 yield()：释放当前cpu的执行 join()：在线程a中调用线程b的join()，此时线程a就进入阻塞状态，知道线程b完全执行完以后，线程a才结束阻塞状态。 stop()：已过
java常见的线程安全问题及代码示例
学亮编程手记
06-01 754
线程安全问题是指在多线程环境下，多个线程对共享资源进行并发访问和操作时可能引发的问题。当多个线程同时读取、写入或修改共享数据时，可能会导致数据不一致、逻辑错误、竞态条件（Race Condition）或死锁等问题。以下是几种常见的线程安全问题：数据竞争（Data Race）：当多个线程同时访问和修改共享数据时，没有适当的同步机制来保护数据一致性，可能导致未定义的行为和不可预测的结果。资源竞争（Resource Contention）：多个线程同时竞争有限的资源，如共享内存、文件、网络连接等。
Java多线程之synchronized关键词（Demo详解）
辰兮要努力
05-31 2462
你好我是辰兮，很高兴你能来阅读，本篇文章为大家讲解Java多线程之synchronized关键词，下面有案例的截图和相关代码可以自行实践，相关的更多面试知识已经提前整理好文章可以阅读学习，分享获取新知，希望对Java初学者有帮助。 1.Java线程的实现方式： Java线程的实现方式详解 2.线程进程基础知识参考： 进程线程的面试问题小结 3.线程面试常见问题参考： Java常见多线程基础面试问题 文章目录一、序言二、同步代码块和对象锁的使用三、同步代码块和类锁的使用四、 同步方法 一、序言.
Java学习(7):多线程之Tread类
zxf_0601的博客
04-09 677
一,Thread类:是多线程最基础的类之一,里面的start()方法是启动新的线程的方法.很多Java中继承Thread类的实现类或者实现Runnable接口的类都通过该方法启动线程,让cpu分配资源调用该线程的run方法.下面将详细介绍Thread类的构成,和实现原理,由于该类好多方法是Native本地方法,是jvm底层去实现的(一般是Java语言无法实现通过c语言实现的)我能只能去理解这些本地...
java的四种引用类型
weixin_44627989的博客
03-31 270
title: java的四种引用类型 引用队列 ReferenceQueue,引用队列内部维护一个Lock锁，除了强引用，其他类型引用都包含一个可以传入引用队列的构造函数 引用的对象在即将被回收时，会把绑定了引用队列的引用加入引用队列 然后回收该对象，因为这时其会变为InActive（死亡 ） Reference抽象类 /*引用实例处于四种可能的内部状态之一： * *活性：由垃圾收集...
解决 calibration.cpp:3408: error: (-210:Unsupported format or combination of formats)
AI小白炼金术师
09-18 1795
官方API对参数的描述，参数调试截图（错误代码行）:给函数 cal_img.object_points, cal_img.corners，均是np类型数组，如下图1所示:实际上，函数需要多张输入图片，读取成list或者np类型，该类型中每一个存储都是np类型，且必须是整数，如下图2所示，读者可以好好比对一下。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值