本文目录一览:
JAVA中如何保证线程安全以及主键自增有序
JAVA中如何保证线程安全以及主键自增有序
一、常见场景
多个线程针对一个i进行主键自增。多线程下如果不做安全策略,将会导致各个现成获取的i值重复,导致脏数据
常见策略
1、增加syschroize进行线程同步
2、使用lock、unlock处理
3、使用reetrantent 锁进行锁定
缺点:容易造成性能低下,或者编写代码容易造成死锁
二、新方案
jdk新提供的功能,atomicInteger(还有其他一atomic开头的原子性操作类)
AtomicInteger,一个提供原子操作的Integer的类。在Java语言中,++i和i++操作并不是线程安全的,在使用的时候,不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。
原理:通过java的CAS compare and swap,简称cas原语进行操作提升性能,这个也号称乐观锁,不阻塞
观锁实际上并不加锁,当计算遇到冲突或者说前后不一致时会重试 直到成功
CAS有3个操作数 内存值V 要跟内存值做比较的值A 和 新值 B
[html] view plain copy
while(true){
if(V == A){
V = B;
return ;
}else{
A = V;
}
}
CAS的操作对象为volatile类型
volatile类型变量是:CPU直接读写变量所在的内存 而不是把变量copy到寄存器操作
这样对变量的操作所有线程都是可见的
这样做的结果是减少了并发时冲突的概率 但不能完全避免
如何解决java中线程安全问题
java中,线程安全的解决方法或过程:
1.如果对象是immutable,则是线程安全的,例如:String,可以放心使用。
2. 如果对象是线程安全的,则放心使用。
3.有条件线程安全,对于Vector和Hashtable一般情况下是线程安全的,但是对于某些特殊情况,需要通过额外的synchronized保证线程安全。
4.使用synchronized关键字。
java中怎么既能高并发效率又能线程安全
总的结论:java是线程安全的,即对任何方法(包括静态方法)都可以不考虑线程冲突,但有一个前提,就是不能存在全局变量。如果存在全局变量,则需要使用同步机制。
如下通过一组对比例子从头讲解:
在多线程中使用静态方法会发生什么事?也就是说多线程访问同一个类的static静态方法会发生什么事?是否会发生线程安全问题?
public class Test {
public static void operation(){
// ... do something
}
}
事实证明只要在静态函数中没有处理多线程共享数据,就不存在着多线程访问同一个静态方法会出现资源冲突的问题。下面看一个例子:
public class StaticThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
StaticAction.print();
}
public static void main(String[] args) {
for (int i = 0; i 100; i++) {
new Thread(new StaticThread()).start();
}
}
}
public class StaticAction {
public static int i = 0;
public static void print() {
int sum = 0;
for (int i = 0; i 10; i++) {
System.out.print("step " + i + " is running.");
sum += i;
}
if (sum != 45) {
System.out.println("Thread error!");
System.exit(0);
}
System.out.println("sum is " + sum);
Java中如何保证线程安全性
并发(concurrency)一个并不陌生的词,简单来说,就是cpu在同一时刻执行多个任务。
而Java并发则由多线程实现的。
在jvm的世界里,线程就像不相干的平行空间,串行在虚拟机中。(当然这是比较笼统的说法,线程之间是可以交互的,他们也不一定是串行。)
多线程的存在就是压榨cpu,提高程序性能,还能减少一定的设计复杂度(用现实的时间思维设计程序)。
这么说来似乎线程就是传说中的银弹了,可事实告诉我们真正的银弹并不存在。
多线程会引出很多难以避免的问题, 如死锁,脏数据,线程管理的额外开销,等等。更大大增加了程序设计的复杂度。
但他的优点依旧不可替代。
死锁和脏数据就是典型的线程安全问题。
简单来说,线程安全就是: 在多线程环境中,能永远保证程序的正确性。
只有存在共享数据时才需要考虑线程安全问题。
java内存区域:
其中, 方法区和堆就是主要的线程共享区域。那么就是说共享对象只可能是类的属性域或静态域。
了解了线程安全问题的一些基本概念后, 我们就来说说如何解决线程安全问题。我们来从一个简单的servlet示例来分析:
public class ReqCounterServlet extends HttpServlet{ private int count = 0;
public void doGet(HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException {
count++;
System.out.print("当前已达到的请求数为" + count);
}
public void doPost(HttpServletRequest request,
HttpServletResponse response) throws IOException, ServletException { // ignore }
}
1. 了解业务场景的线程模型
这里的线程模型指的是: 在该业务场景下, 可能出现的线程调用实况。
众所周知,Servlet是被设计为单实例,在请求进入tomcat后,由Connector建立连接,再讲请求分发给内部线程池中的Processor,
此时Servlet就处于一个多线程环境。即如果存在几个请求同时访问某个servlet,就可能会有几个线程同时访问该servlet对象。如图:
线程模型,如果简单的话,就在脑海模拟一下就好了,复杂的话就可以用纸笔或其他工具画出来。
2. 找出共享对象
这里的共享对象就很明显就是ReqCounterServlet。
3. 分析共享对象的不变性条件
不变性条件,这个名词是在契约式编程的概念中的。不变性条件保证类的状态在任何功能被执行后都保持在一个可接受的状态。
这里可以引申出, 不可变对象是线程安全的。(因为不可变对象就没有不变性条件)
不变性条件则主要由对可变状态的修改与访问构成。
这里的servlet很简单, 不变性条件大致可以归纳为: 每次请求进入时count计数必须加一,且计数必须正确。
在复杂的业务中, 类的不变性条件往往很难考虑周全。设计的世界是险恶的,只能小心谨慎,用测量去证明,最大程度地减少错误出现的几率。
4. 用特定的策略解决线程安全问题。
如何解决的确是该流程的重点。目前分三种方式解决:
第一种,修改线程模型。即不在线程之间共享该状态变量。一般这个改动比较大,需要量力而行。
第二种,将对象变为不可变对象。有时候实现不了。
第三种,就比较通用了,在访问状态变量时使用同步。 synchronized和Lock都可以实现同步。简单点说,就是在你修改或访问可变状态时加锁,独占对象,让其他线程进不来。
这也算是一种线程隔离的办法。(这种方式也有不少缺点,比如说死锁,性能问题等等)
其实有一种更好的办法,就是设计线程安全类。《代码大全》就有提过,问题解决得越早,花费的代价就越小。
是的,在设计时,就考虑线程安全问题会容易的多。
首先考虑该类是否会存在于多线程环境。如果不是,则不考虑线程安全。
然后考虑该类是否能设计为不可变对象,或者事实不可变对象。如果是,则不考虑线程安全
最后,根据流程来设计线程安全类。
设计线程安全类流程:
1、找出构成对象状态的所有变量。
2、找出约束状态变量的不变性条件。
3、建立对象状态的并发访问管理策略。
有两种常用的并发访问管理策略:
1、java监视器模式。 一直使用某一对象的锁来保护某状态。
2、线程安全委托。 将类的线程安全性委托给某个或多个线程安全的状态变量。(注意多个时,这些变量必须是彼此独立,且不存在相关联的不变性条件。)
Java中如何使方法线程安全
线程不安全的场合很多,比如像操作系统中的用户界面、打印机等外设、控制台输出,都不允许并发(设想两个程序同时要输出文字到同一个屏幕,那还不乱套了)
在代码中,每个线程有自己的堆栈但是共享整个堆,所以访问那些全局的变量,也必须同步,否则会出现脏读数据。
同步也不是万能的良药。不当的锁定会导致程序死锁,而且多线程本身就是为了提高性能,但是同步使用多了,程序又实质上退化成了单线程程序,用多线程的意义也就没了。