java线程安全
A. java中如何保证线程安全性
并发（concurrency）一个并不陌生的词，简单来说，就是cpu在同一时刻执行多个任务。
而Java并发则由多线程实现的。
在jvm的世界里，线程就像不相干的平行空间，串行在虚拟机中。（当然这是比较笼统的说法，线程之间是可以交互的，他们也不一定是串行。）
多线程的存在就是压榨cpu，提高程序性能，还能减少一定的设计复杂度（用现实的时间思维设计程序）。
这么说来似乎线程就是传说中的银弹了，可事实告诉我们真正的银弹并不存在。
多线程会引出很多难以避免的问题， 如死锁，脏数据，线程管理的额外开销，等等。更大大增加了程序设计的复杂度。
但他的优点依旧不可替代。
死锁和脏数据就是典型的线程安全问题。
简单来说，线程安全就是：在多线程环境中，能永远保证程序的正确性。
只有存在共享数据时才需要考虑线程安全问题。
java内存区域：
其中，方法区和堆就是主要的线程共享区域。那么就是说共享对象只可能是类的属性域或静态域。
了解了线程安全问题的一些基本概念后， 我们就来说说如何解决线程安全问题。我们来从一个简单的servlet示例来分析：
1. 了解业务场景的线程模型
这里的线程模型指的是: 在该业务场景下， 可能出现的线程调用实况。
众所周知，Servlet是被设计为单实例，在请求进入tomcat后，由Connector建立连接，再讲请求分发给内部线程池中的Processor，
此时Servlet就处于一个多线程环境。即如果存在几个请求同时访问某个servlet，就可能会有几个线程同时访问该servlet对象。如图：
线程模型，如果简单的话，就在脑海模拟一下就好了，复杂的话就可以用纸笔或其他工具画出来。
2. 找出共享对象
这里的共享对象就很明显就是ReqCounterServlet。
3. 分析共享对象的不变性条件
不变性条件，这个名词是在契约式编程的概念中的。不变性条件保证类的状态在任何功能被执行后都保持在一个可接受的状态。
这里可以引申出，不可变对象是线程安全的。（因为不可变对象就没有不变性条件）
不变性条件则主要由对可变状态的修改与访问构成。
这里的servlet很简单， 不变性条件大致可以归纳为： 每次请求进入时count计数必须加一，且计数必须正确。
在复杂的业务中， 类的不变性条件往往很难考虑周全。设计的世界是险恶的，只能小心谨慎，用测量去证明，最大程度地减少错误出现的几率。
4. 用特定的策略解决线程安全问题。
如何解决的确是该流程的重点。目前分三种方式解决：
第一种，修改线程模型。即不在线程之间共享该状态变量。一般这个改动比较大，需要量力而行。
第二种，将对象变为不可变对象。有时候实现不了。
第三种，就比较通用了，在访问状态变量时使用同步。 synchronized和Lock都可以实现同步。简单点说，就是在你修改或访问可变状态时加锁，独占对象，让其他线程进不来。
这也算是一种线程隔离的办法。（这种方式也有不少缺点，比如说死锁，性能问题等等）
其实有一种更好的办法，就是设计线程安全类。《代码大全》就有提过，问题解决得越早，花费的代价就越小。
是的，在设计时，就考虑线程安全问题会容易的多。
首先考虑该类是否会存在于多线程环境。如果不是，则不考虑线程安全。
然后考虑该类是否能设计为不可变对象，或者事实不可变对象。如果是，则不考虑线程安全
最后，根据流程来设计线程安全类。
设计线程安全类流程：
1、找出构成对象状态的所有变量。
2、找出约束状态变量的不变性条件。
3、建立对象状态的并发访问管理策略。
有两种常用的并发访问管理策略：
1、java监视器模式。 一直使用某一对象的锁来保护某状态。
2、线程安全委托。将类的线程安全性委托给某个或多个线程安全的状态变量。（注意多个时，这些变量必须是彼此独立，且不存在相关联的不变性条件。）
B. Java中如何使方法线程安全
线程不安全的场合很多，比如像操作系统中的用户界面、打印机等外设、控制台输出，都不允许并发（设想两个程序同时要输出文字到同一个屏幕，那还不乱套了）
在代码中，每个线程有自己的堆栈但是共享整个堆，所以访问那些全局的变量，也必须同步，否则会出现脏读数据。
同步也不是万能的良药。不当的锁定会导致程序死锁，而且多线程本身就是为了提高性能，但是同步使用多了，程序又实质上退化成了单线程程序，用多线程的意义也就没了。
C. java里线程安全是什么意思有什么作用
比如说，两个线程操作同一个ArrayList变量，那么一个线程这一时刻读的数据可能在下一刻要改变。
一般在类似于下面的情景下考虑线程安全的问题：
ArrayList procts=new ArrayList ();
procts用来存放生产出来的产品。
现在假设：有3个消费者线程，2个生产者线程。
每个生产者线程生产出一个产品，执行
procts.add(new Proct（）);
每个消费者线程消费一个产品执行
if(procts.size()>=1){ procts.remove(0);}
如果procts里现在只有一个产品可以消费，但是有2个消费者线程请求消费，那么就有可能出现一个产品被同时消费的问题，而这是和实际不符的。
但是不同的线程访问Vector的时候不会发生这种错误，因为java会有相应的机制是同一时刻只有一个线程对这个变量操作。
这就是所谓的：
Vector：是线程安全的
ArrayList：不是线程安全的
D. java中哪些线程安全
JAVA中线程安全的map有：Hashtable、synchronizedMap、ConcurrentHashMap。
java中map中线程安全怎么实现：
1、同步的map就是Hashtable, concurrenthashmap。
2、你看到的Hashtable就是直接在hashmap上加了个锁，concurrenthashmap就是分成多个分段锁。
java代码中线程安全级别：
1、绝对线程安全。
在任何环境下，调用者都不需要考虑额外的同步措施，都能够保证程序的正确性。这个定义要求很严格，java里面满足这个要求的类比较少，对于实现jsr133规范（java内存模型）的jdk（一般指jdk5.0之上），一般的不变类都是满足绝地线程安全的。比如 String，Integer类。一般情况下，定义了如果一个类里面所有字段都是final类型的，一般都认为这个类是不变的。不变类都是绝对线程安全的。
2、相对线程安全
在一般情况下，调用者都不需要考虑线程同步，大多数情况下，都能够正常运行。jdk里面大多数类都是相对安全的。最常见的例子是java里面Vector类。
E. java中的线程安全问题
通常是指线程间，操作共用的变量，不会造成混乱。
加了 synchronized 是让线程锁定、别的线程等待
F. java中的线程安全是什么什么叫线程安全什么叫不安全
java中的线程安全是什么：
就是线程同步的意思，就是当一个程序对一个线程安全的方法或者语句进行访问的时候，其他的不能再对他进行操作了，必须等到这次访问结束以后才能对这个线程安全的方法进行访问
什么叫线程安全：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题都是由全局变量及静态变量引起的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。
G. Java中的类如何保证线程安全
java中，线程安全的解决方法或过程：
1.如果对象是immutable，则是线程安全的，例如:String，可以放心使用。
2. 如果对象是线程安全的，则放心使用。
3.有条件线程安全，对于Vector和Hashtable一般情况下是线程安全的，但是对于某些特殊情况，需要通过额外的synchronized保证线程安全。
4.使用synchronized关键字。
H. 在java中什么是线程安全的
ArrayList和HashMap是异步的，
Vector和HashTable是同步的
List本身是一个接口，有一个类叫Vector，它实现了List，并且这个Vector是线程同步的。 在实际运用中，至少我没看见谁直接用List来装东西，最多会是这样:
List list = new ArrayList();
List list = new Vector();
I. java什么叫线程安全
Count.java：
[java]view plainprint?
publicclassCount{
privateintnum;
publicvoidcount(){
for(inti=1;i<=10;i++){
num+=i;
}
System.out.println(Thread.currentThread().getName()+"-"+num);
}
}
- 在这个类中的count方法是计算1一直加到10的和，并输出当前线程名和总和，我们期望的是每个线程都会输出55。
publicclassThreadTest{
publicstaticvoidmain(String[]args){
Runnablerunnable=newRunnable(){
Countcount=newCount();
publicvoidrun(){
count.count();
}
};
for(inti=0;i<10;i++){
newThread(runnable).start();
}
}
}
- 这里启动了10个线程，看一下输出结果：
Thread-0-55
Thread-1-110
Thread-2-165
Thread-4-220
Thread-5-275
Thread-6-330
Thread-3-385
Thread-7-440
Thread-8-495
Thread-9-550
- 只有Thread-0线程输出的结果是我们期望的，而输出的是每次都累加的，这里累加的原因以后的博文会说明，那么要想得到我们期望的结果，有几种解决方案：
publicclassCount{
publicvoidcount(){
intnum=0;
for(inti=1;i<=10;i++){
num+=i;
}
System.out.println(Thread.currentThread().getName()+"-"+num);
}
}
publicclassThreadTest4{
publicstaticvoidmain(String[]args){
Runnablerunnable=newRunnable(){
publicvoidrun(){
Countcount=newCount();
count.count();
}
};
for(inti=0;i<10;i++){
newThread(runnable).start();
}
}
}
ThreadTest.java：
[java]view plainprint?
[java]view plainprint?
1. 将Count中num变成count方法的局部变量；
[java]view plainprint?
2. 将线程类成员变量拿到run方法中，这时count引用是线程内的局部变量；
[java]view plainprint?
3. 每次启动一个线程使用不同的线程类，不推荐。
上述测试，我们发现，存在成员变量的类用于多线程时是不安全的，不安全体现在这个成员变量可能发生非原子性的操作，而变量定义在方法内也就是局部变量是线程安全的。想想在使用struts1时，不推荐创建成员变量，因为action是单例的，如果创建了成员变量，就会存在线程不安全的隐患，而struts2是每一次请求都会创建一个action，就不用考虑线程安全的问题。所以，日常开发中，通常需要考虑成员变量或者说全局变量在多线程环境下，是否会引发一些问题。
J. java线程安全性问题
//下次发源代码时先整理好再发出来,累死了~呼呼
packaget;
importjava.io.File;
importjava.io.IOException;
importjava.util.Iterator;
importjava.util.List;
importjavax.servlet.ServletConfig;
importjavax.servlet.ServletContext;
importjavax.servlet.ServletException;
importjavax.servlet.http.HttpServlet;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
/**
*先帮你整理下,你这样估计没几人愿意看:
*
*@authorHuangYong
*
*/
{
//验证版本是否一致的java身份证
=-5318854875823790516L;
//上传的组件中要运用到的对象
privateServletContextsc;
//保存路径
privateStringsavePath;
publicvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)
throwsServletException,IOException{
doPost(request,response);
}
publicvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse)
throwsServletException,IOException{
//解决中文乱码问题，后面可以看看过滤器
request.setCharacterEncoding("UTF-8");
//设计模式中的工厂模式
DiskFileItemFactoryfactory=newDiskFileItemFactory();
//用来在Servlet中完成文件
ServletFileUploapload=newServletFileUpload(factory);
try{
Listitems=upload.parseRequest(request);
Iteratorit=items.iterator();
while(it.hasNext()){
//包括传过来的所有信息，包括文件和普通文本信息
FileItemitem=(FileItem)it.next();
//这个方法判断信息类型，普通文本为true文件为false
if(item.isFormField()){
System.out.println("上传的表单项的名称:"+item.getFieldName());
System.out.println("内容:"+item.getString("UTF-8"));
}else{
if(item.getName()!=null&&!item.getName().equals("")){
System.out.println("上传文件的文件大小："+item.getSize());
System.out
.println("上传文件的文件类型："+item.getContentType());
System.out.println("上传文件的文件名字："+item.getName());
Filetempfile=newFile(item.getName());
//sc.getRealPath("/")代表获得当前应用的物理路径
//,savePath为上传文件保存在服务器上的地址，自己在web.xml下设好的
Filefile=newFile(sc.getRealPath("/")+savePath
+tempfile.getName());
//将上传的文件保存在服务器的物理磁盘目录下
item.write(file);
//在jsp页面上现实上传的结果
}
}
}
//解析文件
}catch(Exceptione){
thrownewRuntimeException(e);
}
}
publicvoidinit(ServletConfigconfig)throwsServletException{
//这是自己设的参数，用于保存上传文件应当保存的目录地址，在xml文件中初始化
savePath=config.getInitParameter("savePath");
sc=config.getServletContext();
}
}
首先, 成员变量用private修饰就是为了不让外部程序随意访问, 如果需要暴露给外部使用时, 通常需要getter访问器来控制权限, 框架程序除外;
关于成员变量引起的线程安全问题根据需求来控制, 如果没有必要时直接定义在方法体内就没有线程安全问题了, 象JDBC的对象(Connection, PreparedStatement, ResultSet..)直接在方法体内部定义;
sc 和 savePath 正常情况下没有线程安全问题, 不过你存储上传的文件时要小心同名文件问题
希望能帮助你