java 基础，关于线程安全

最新推荐文章于 2023-02-05 08:00:00 发布
最新推荐文章于 2023-02-05 08:00:00 发布
阅读量638 收藏
点赞数
文章标签： java thread string class 多线程 integer
 

http://www.blogjava.net/lingyu/articles/322848.html　

线程安全的本质体现在两个方面，

　　Ａ变量安全：多线程同时运行一段代码

　　Ｂ线程同步：一个线程还没执行完，另一个线程又进来接着执行。

　看个简单的例子。

 

public class ThreadSafe implements java.lang.Runnable {
	
	int num = 1;
	public void run() {
		for (int i = 0; i < 3; i++) {
			num = num + 1;
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + num);
		}
	}

}


 

TestMan.java 写道
package com.java.thread.test;

public class TestMan {
public static void main(String[] args) {
Runnable safe=new ThreadSafe();
Thread thread1=new Thread(safe,"thread1");
Thread thread2=new Thread(safe,"thread2");
thread1.start();
thread2.start();
}

}

 运行结果

num is value +===thread2---------3
num is value +===thread1---------4
num is value +===thread2---------5
num is value +===thread1---------6
num is value +===thread1---------7
num is value +===thread2---------7

很明显是错误的，应为两个线程共享同一个变量。这里就是变量的安全问题。

解决办法：

１抛弃单实例，多线程的方式，用多实例，多线程的方式，这样就和单线程是一个样了，不会出错，但是是最接近传统的编程模式

２不要用类的实例变量，经可能把变量封装到方法内部。

3.ThreadLocal

.4.用synchronized让线程同步化（没有办法的办法，因为使用线程就是为了异步，提高程序处理速度）

１类的解决办法的代码。

Java代码
  1. public class TestMan {  
  2.     public static void main(String[] args) {  
  3.         Runnable safe=new ThreadSafe();  
  4.         Runnable safe2=new ThreadSafe();  
  5.         Thread thread1=new Thread(safe,"thread1");  
  6.         Thread thread2=new Thread(safe2,"thread2");  
  7.         thread1.start();  
  8.         thread2.start();  
  9.     }  
  10.   
  11. }   
public class TestMan {
public static void main(String[] args) {
Runnable safe=new ThreadSafe();
Runnable safe2=new ThreadSafe();
Thread thread1=new Thread(safe,"thread1");
Thread thread2=new Thread(safe2,"thread2");
thread1.start();
thread2.start();
}
}

 

运行结果

num is value +===thread1---------2
num is value +===thread2---------2
num is value +===thread1---------3
num is value +===thread2---------3
num is value +===thread1---------4
num is value +===thread2---------4
２类解决办法的代码

Java代码
  1. public class ThreadSafe implements java.lang.Runnable {  
  2.       
  3.     public void run() {  
  4.         int num = 1;  
  5.         for (int i = 0; i < 3; i++) {  
  6.             num = num + 1;  
  7.             try {  
  8.                 Thread.sleep(2000);  
  9.             } catch (InterruptedException e) {  
  10.                 e.printStackTrace();  
  11.             }  
  12.             System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + num);  
  13.         }  
  14.     }  
  15.   
  16. }   
public class ThreadSafe implements java.lang.Runnable {
public void run() {
int num = 1;
for (int i = 0; i < 3; i++) {
num = num + 1;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + num);
}
}
}

 

Java代码
  1. public class TestMan {  
  2.     public static void main(String[] args) {  
  3.         Runnable safe=new ThreadSafe();  
  4.   
  5.         Thread thread1=new Thread(safe,"thread1");  
  6.         Thread thread2=new Thread(safe,"thread2");  
  7.         thread1.start();  
  8.         thread2.start();  
  9.     }  
  10.   
  11. }   
public class TestMan {
public static void main(String[] args) {
Runnable safe=new ThreadSafe();
Thread thread1=new Thread(safe,"thread1");
Thread thread2=new Thread(safe,"thread2");
thread1.start();
thread2.start();
}
}

 运行结果

num is value +===thread2---------2
num is value +===thread1---------2
num is value +===thread1---------3
num is value +===thread2---------3
num is value +===thread1---------4
num is value +===thread2---------4

 

这两种办法，比较推荐适用第二个办法，就是把变量经可能的封装到风发内部，这样他们就是线程的私有变量了。另外，从jdk1.2后，推出了 threadlocal　对象，它作为线程的一个局部变量，可以为每个线程创建一个副本，用来保存每个线程的属性，各是各的，互不干扰。单每个 threadlocal变量只能保存一个变量，假如有多个变量要保存，那么就要写多个threadlocal对象。

 

我们把代码改写一下。

Java代码
  1. public class ThreadSafe implements java.lang.Runnable {  
  2.     ThreadLocal<Integer> local=new ThreadLocal<Integer>();  
  3.     public void run() {  
  4.         for (int i = 0; i < 3; i++) {  
  5.             if(local.get()==null){  
  6.                 local.set(new Integer(1));  
  7.             }  
  8.             int num=local.get().intValue();  
  9.             num=num+1;  
  10.             local.set(new Integer(num));  
  11.             try {  
  12.                 Thread.sleep(2000);  
  13.             } catch (InterruptedException e) {  
  14.                 e.printStackTrace();  
  15.             }  
  16.             System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + local.get().intValue());  
  17.         }  
  18.     }  
  19.   
  20. }   
public class ThreadSafe implements java.lang.Runnable {
ThreadLocal<Integer> local=new ThreadLocal<Integer>();
public void run() {
for (int i = 0; i < 3; i++) {
if(local.get()==null){
local.set(new Integer(1));
}
int num=local.get().intValue();
num=num+1;
local.set(new Integer(num));
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + local.get().intValue());
}
}
}

 

Java代码
  1. public class TestMan {  
  2.     public static void main(String[] args) {  
  3.         Runnable safe=new ThreadSafe();  
  4.         Thread thread1=new Thread(safe,"thread1");  
  5.         Thread thread2=new Thread(safe,"thread2");  
  6.         thread1.start();  
  7.         thread2.start();  
  8.     }  
  9.   
  10. }   
public class TestMan {
public static void main(String[] args) {
Runnable safe=new ThreadSafe();
Thread thread1=new Thread(safe,"thread1");
Thread thread2=new Thread(safe,"thread2");
thread1.start();
thread2.start();
}
}

 运行结果

num is value +===thread2---------2
num is value +===thread1---------2
num is value +===thread1---------3
num is value +===thread2---------3
num is value +===thread1---------4
num is value +===thread2---------4

结果是一样的，所以这里变量安全有３个办法可以解决。

 

然后在说说线程的同步的问题。我们看上面的运行结果。

num is value +===thread2---------2
num is value +===thread1---------2
num is value +===thread1---------3
num is value +===thread2---------3
num is value +===thread1---------4
num is value +===thread2---------4

就　可以看出他们不是线程同步的，是thread1和thread2在交替执行的。在有些情况下，要求一段代码在运行的过程中是一个不可分割的实体，就是原子的。就是说当已经有线程在执行这段代码的时候，其他的线程必须等待他执行完毕后才能竟来执行，这就是所谓的线程同步。

 

java通过同步锁来执行线程的同步和等待，也就是说，要不间断执行的代码需要放在synchronized关键字标识的代码块中。可以用来修饰代码块，也可以修饰方法。

 

Java代码
  1. public class ThreadSafe implements java.lang.Runnable{  
  2.     public synchronized void run() {  
  3.         int num = 1;  
  4.         for (int i = 0; i < 3; i++) {  
  5.             num = num + 1;  
  6.             try {  
  7.                 Thread.sleep(2000);  
  8.             } catch (InterruptedException e) {  
  9.                 e.printStackTrace();  
  10.             }  
  11.             System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + num);  
  12.         }  
  13.     }  
  14.   
  15.   
  16. }   
public class ThreadSafe implements java.lang.Runnable{
public synchronized void run() {
int num = 1;
for (int i = 0; i < 3; i++) {
num = num + 1;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("num is value +==="+Thread.currentThread().getName()+"---------" + num);
}
}
}

 

Java代码
  1. public class TestMan {  
  2.     public static void main(String[] args) {  
  3.         Runnable safe=new ThreadSafe();  
  4.         Thread thread1=new Thread(safe,"thread1");  
  5.         Thread thread2=new Thread(safe,"thread2");  
  6.         thread1.start();  
  7.         thread2.start();  
  8.     }  
  9.   
  10. }   
public class TestMan {
public static void main(String[] args) {
Runnable safe=new ThreadSafe();
Thread thread1=new Thread(safe,"thread1");
Thread thread2=new Thread(safe,"thread2");
thread1.start();
thread2.start();
}
}

 运行结果

um is value +===thread1---------2
num is value +===thread1---------3
num is value +===thread1---------4
num is value +===thread2---------2
num is value +===thread2---------3
num is value +===thread2---------4

 

可以看到thread1运行结束后thread2才开始运行的。代码还可以这么写

Java代码
  1. public class ThreadSafe implements java.lang.Runnable {  
  2.     public void run() {  
  3.         int num = 1;  
  4.         synchronized (this) {  
  5.             for (int i = 0; i < 3; i++) {  
  6.                 num = num + 1;  
  7.                 try {  
  8.                     Thread.sleep(2000);  
  9.                 } catch (InterruptedException e) {  
  10.                     e.printStackTrace();  
  11.                 }  
  12.                 System.out.println("num is value +==="  
  13.                         + Thread.currentThread().getName() + "---------" + num);  
  14.             }  
  15.         }  
  16.     }  
  17.   
  18. }   
public class ThreadSafe implements java.lang.Runnable {
public void run() {
int num = 1;
synchronized (this) {
for (int i = 0; i < 3; i++) {
num = num + 1;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("num is value +==="
+ Thread.currentThread().getName() + "---------" + num);
}
}
}
}

 

在启用同步锁机制以后，需要避免

１无线等待，，线程Ｂ等待线程Ａ执行完毕，然后线程Ａ确进入了死循环。

２循环等待：两个线程相互调用，都要求要同步执行，这个时候就先会循环等待，我等你执行，你也在等我执行，这个时候就死锁了

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

践行者风信子
关注
Java线程安全基础概念解析
08-29
Java线程安全基础概念解析 ...Java线程安全基础概念解析是Java编程语言中一个非常重要的概念，开发者需要充分了解线程安全的定义、Java语言中的线程安全和线程安全的实现方法，以便编写更加高效、可靠的多线程程序。
Java线程：线程安全与不安全
12-22
作为一个Java web开发人员，很少也不需要去处理线程，因为服务器已经帮我们处理好了。记得大一刚学Java的时候，老师带着我们做了一个局域网聊天室，用到了AWT、Socket、多线程、I/O，编写的客户端和服务器，当时做...
【Java基础】---线程安全
chencangui的专栏
07-29 214
目录 1、简介 在多线程的的使用场景中，如果对于同一个对象中的实例变量并发进行访问的话，可能会产生“脏数据”的情况，而想要避免出现这种情况的方法就是进行同步处理。常用的就是使用synchronized、volatile来实现。但在日常开发中可能经常会出现使用不当而导致各种各样的异常问题，例如死锁、带来的执行性能问题等。下面就对两种类型做详细的介绍。 2、synchroni...
【Java基础】 线程安全
weixin_55175040的博客
07-13 105
一、线程安全 1、什么是线程不安全 当多个线程访问同一个对象 线程同步：同一进程的多个线程共享同一块存储空间，同步的必要条件：队列+锁(synchronized) 同步导致的问题 一个线程持有锁，其他线程等待，优先级倒置，导致性能低下 优先级高的等待优先级低的线程释放锁，导致性能导致 多线程竞争下，加锁释放锁导致上下文切换和调度延时，也会导致性能低下 二、死锁 1、什么是死锁 两个或两个以上的线程在执行过程中，由于竞争资源而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去 2、死锁的条件 互斥
java中的线程安全
学习、分享
03-20 1227
java中的线程安全
Java中的线程安全问题
脚印
11-23 1176
线程安全 线程安全：如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，此时我们就称之为是线程安全的。 我们通过一个案例，演示线程的安全问题： 电影院卖票，使用了A、B、C三个窗口进行卖票，电影票总数为100张 采用线程对象来模拟卖票窗口A、B、C；使用Runnable接口的子类来模拟买的电影票 模拟电影票...
Java中的线程安全和线程不安全
127.0.0.1
06-05 613
线程安全：多条线程访问时，采用同步或者添加锁机制（详见：https://blog.csdn.net/edison_style/article/details/80566909），当一条线程访问完，其他线程才能访问，这就是线程安全。线程不安全：多条线程同时进入代码块进行操作，造成数据重复使用等脏数据的情况。...
java线程基础
12-21
原子性是线程安全的一个关键特性，保证操作不可分割，例如，`a += b` 在多线程环境下应被视为原子操作，防止数据的不一致。`volatile` 关键字用于保证变量的可见性，确保一个线程对变量的修改能够立即被其他线程看到...
Java线程安全的常用类_动力节点Java学院整理
08-30
Java线程安全的常用类 Java线程安全的常用类是指在集合框架中，具有线程安全的类这些类都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。这些线程安全的类的方法都是同步的，每次只能一个访问。...
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
java基础—线程安全的定义
Daopin Blog
12-08 992
定义线程安全，我比较认可的是在《Java concurrency in practice》一书中的定义： 一个不论运行时（Runtime）如何调度线程都不需要调用方提供额外的同步和协调机制还能正确地运行的类是线程安全的 多线程的场景很多很复杂，难以穷尽地说那些条件下是或者不是线程安全的，但是有一些常用的肯定线程安全的场景： 1.无状态的一定是线程安全的。这个很好理解，因为所谓线程不安全也就是
Java 中的线程安全容器
roseduan 的个人博客
05-25 668
一、同步容器 常用的一些容器例如 ArrayList、HashMap、都不是线程安全的，最简单的将这些容器变为线程安全的方式，是给这些容器所有的方法都加上 synchronized 关键字。 Java 的 Collections 中实现了这些同步容器： 简单的使用如下： List<String> list = Collections.synchronizedList(new Arra...
java线程代码块如何加群,如何在java中确保代码块不会被任何其他线程中断
weixin_35549786的博客
02-25 180
exampl:new Thread(new Runnable() {public void run() {while(condition) {*code that must not be interrupted**some more code*}}}).start();SomeOtherThread.start();YetAntherThread.start();How can you ensur...
Java面试题
IXingFu的博客
07-24 96
47. 在 java 程序中怎么保证多线程的运行安全？ 使用安全类(concurrent)下面的类。使用自动锁 synchronized。使用手动锁 Lock。保证一个或者多个操作在CPU执行的过程中不被中断。保证一个线程对共享变量的修改，另外一个线程能够立刻看到。保证程序执行的顺序按照代码的先后顺序执行。 synchronized示例： public static void main(String[] args) { MyThread01 thread = new MyThread
2023最新版多线程面试题（三）（持续更新中）
最新发布
weixin_54828627的博客
02-05 543
26、什么是线程组，为什么在 Java 中不推荐使用?线程组和线程池是两个不同的概念，他们的作用完全不同，前者是为了方便线程的管理，后者是为了管理线程的生命周期，复用线程，减少创建销毁线程的开销。27、为什么使用 Executor 框架比使用应用创建和管理线程好?为什么要使用 Executor 线程池框架每次执行任务创建线程 new Thread0比较消耗性能，创建一个线程是比较耗时、耗资源的。调用 new Thread0创建的线程缺乏管理，被称为野线程，而且可以无限制的创建
java 线程 防止_Java 如何防止线程意外中止
weixin_39721370的博客
02-12 178
Thread的run方法是不抛出任何检查型异常(checked exception)的,但是它自身却可能因为一个异常而被终止，导致这个线程的终结。最麻烦的是，在线程中抛出的异常即使使用try...catch也无法截获，因此可能导致一些问题出现，比如异常的时候无法回收一些系统资源，或者没有关闭当前的连接等等。JDK5.0之前，不能为单独的Thread设置UncaughtExceptionHandle...
java线程安全篇之synchronized 多个线程多个锁（二）
hfbin的博客
11-15 1572
java线程安全篇之synchronized 多个线程多个锁（二）
驱动开发基础 -- 可重入函数、线程安全函数
诸葛一帆丶的博客
06-11 652
转自：https://blog.csdn.net/xiaofei0859/article/details/58185111.什么叫线程安全如果你的程序所在的进程中有多个线程在同时运行，而这些线程可能同时运行一段代码或同时访问一个对象，如果每次运行完这段代码或访问完这个对象之后，所得到的结果和单线程运行的结果一样，而其他变量的值也和预期的保持一致，那么就认为是线程安全的。    也就是说当多个线程同...
JAVA多线程安全的三大特性 + synchronized和volatile
Cai Yu的博客
10-10 3219
线程安全的三大特性   在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。我们先看具体看一下这三个概念： 1. 原子性 　　原子性是指一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。 　　先来看一个例子：使用程序实现一个计数器，期望得到的结果是10000，代码如下： import java.util.concurrent.Executo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值