线程同步的几种方法的总结
线程同步的方式包括：互斥锁、读写锁、条件变量、信号量和令牌。
以Java语言为例：用synchronized关键字修饰同步方法。
同步有几种实现方法分别是synchronized,wait与notifywait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。
同步是多线程中的重要概念。
同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。
同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。
给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。
下面代码是一个同步方法的示例：public synchronized void aMethod() { \\\/\\\/ do something } public static synchronized void anotherMethod() { \\\/\\\/ do something } 线程在执行同步方法时是具有排它性的。
当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。
在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。
同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。
如果这个方法是静态同步方法呢
那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。
同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。
Java中有关多线程并发的几个工具类之总结
从文体上说，心得体会属于散文和议论文范畴。
在行文组织上，也应注意结合这两种体裁的要素。
第一，无论散文或议论文，均需借助行文明确一种主题（或称为一个中心论点）。
例如，对所观事物文章的感受是喜还是恶，是造成或者反对。
这既是一种“感受”，也是文章的灵魂。
因此，心得体会必须有开宗明义的定调，否则如同人没有灵魂。
第二，即使是散文体，心得体会也属于杂述夹议的典型体裁。
也就是说，不必要在文章中大篇幅的抄引原著，关键在于定调、议论、引述，以及旁征博引用于强化和突出自己的中心思想。
第三，心得体会的必须环节是结合实际、 结合自身。
仅是泛泛而谈，是一篇无血肉、无精神的散文；不能提出结合实际和自身的具体思维、具体措施、具体改革，是形式主义、空中楼阁。
综上几种，写一篇规范的心得体会，有几个诀窍：其一，尽量给心得体会文章提出标题，即使不提出标题，也尽量在文章一开始就明确某一种中心思想；其二，注意引征，提出中心思想后的论述既可以是论理，也可以借助大量的史实、事实，突出中心思想；其三，注意结合实际，提出具体可行的措施。
请使用的Java的多线程知识来编写一个程序，实现一个简单的摩天大楼的电梯模型
private Integer skuid;private Breed breed;private Variety variety;private String skuname;
求教，关于多线程在javaweb中的应用
在一个程序中，这些独立运行的程序片断叫作“线程”（Thread），利用它编程的概念就叫作“多线程处理”。
多线程处理一个常见的例子就是用户界面。
利用线程，用户可按下一个按钮，然后程序会立即作出响应，而不是让用户等待程序完成了当前任务以后才开始响应
多线程一定比单线程效率更高吗
看你做什么咯，若是就开一个软件，那都一样，要是开七八个软件，当然是多线程快了
需要线程安全 以及如何实现线程安全
线程安全问题主要是由于实例变量使用不当而引起的，这里以一个现实的例子来说明。
Import javax.servlet. *;Import javax.servlet.http. *;Import java.io. *;Public class Concurrent Test extends HttpServlet {PrintWriter output;Public void service (HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {String username;Response.setContentType (text\\\/html; charset=gb2312);Username = request.getParameter (username);Output = response.getWriter ();Try {Thread. sleep (5000); \\\/\\\/为了突出并发问题，在这设置一个延时} Catch (Interrupted Exception e){}output.println(用户名:+Username+
);}}该Servlet中定义了一个实例变量output，在service方法将其赋值为用户的输出。
当一个用户访问该Servlet时，程序会正常的运行，但当多个用户并发访问时，就可能会出现其它用户的信息显示在另外一些用户的浏览器上的问题。
这是一个严重的问题。
为了突出并发问题，便于测试、观察，我们在回显用户信息时执行了一个延时的操作。
假设已在web.xml配置文件中注册了该Servlet，现有两个用户a和b同时访问该Servlet（可以启动两个IE浏览器，或者在两台机器上同时访问）,即同时在浏览器中输入：a： 8080\\\/servlet\\\/ConcurrentTest? Username=ab： 8080\\\/servlet\\\/ConcurrentTest? Username=b如果用户b比用户a回车的时间稍慢一点，将得到如图2所示的输出：从图2中可以看到，Web服务器启动了两个线程分别处理来自用户a和用户b的请求，但是在用户a的浏览器上却得到一个空白的屏幕，用户a的信息显示在用户b的浏览器上。
该Servlet存在线程不安全问题。
下面我们就从分析该实例的内存模型入手,观察不同时刻实例变量output的值来分析使该Servlet线程不安全的原因。
Java的内存模型JMM（Java Memory Model）JMM主要是为了规定了线程和内存之间的一些关系。
根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有实例变量都储存在主存中，对于所有线程都是共享的。
每条线程都有自己的工作内存(Working Memory)，工作内存由缓存和堆栈两部分组成，缓存中保存的是主存中变量的拷贝，缓存可能并不总和主存同步，也就是缓存中变量的修改可能没有立刻写到主存中；堆栈中保存的是线程的局部变量，线程之间无法相互直接访问堆栈中的变量。
根据JMM，我们可以将论文中所讨论的Servlet实例的内存模型抽象为图3所示的模型。
下面根据图3所示的内存模型，来分析当用户a和b的线程（简称为a线程、b线程）并发执行时，Servlet实例中所涉及变量的变化情况及线程的执行情况，如图4所示。
调度时刻a线程b线程T1访问Servlet页面T2访问Servlet页面T3output=a的输出username=a休眠5000毫秒，让出CPUT4output=b的输出（写回主存）username=b休眠5000毫秒，让出CPUT5在用户b的浏览器上输出a线程的username的值,a线程终止。
T6在用户b的浏览器上输出b线程的username的值,b线程终止。
图4 Servlet实例的线程调度情况从图4中可以清楚的看到，由于b线程对实例变量output的修改覆盖了a线程对实例变量output的修改，从而导致了用户a的信息显示在了用户b的浏览器上。
如果在a线程执行输出语句时，b线程对output的修改还没有刷新到主存，那么将不会出现图2所示的输出结果，因此这只是一种偶然现象，但这更增加了程序潜在的危险性。
设计线程安全的Servlet通过上面的分析，我们知道了实例变量不正确的使用是造成Servlet线程不安全的主要原因。
下面针对该问题给出了三种解决方案并对方案的选取给出了一些参考性的建议。
1、实现 SingleThreadModel 接口该接口指定了系统如何处理对同一个Servlet的调用。
如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。
这种方法只要将前面的Concurrent Test类的类头定义更改为：Public class Concurrent Test extends HttpServlet implements SingleThreadModel {…………}2、同步对共享数据的操作使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段，在本论文中的Servlet可以通过同步块操作来保证线程的安全。
同步后的代码如下：…………Public class Concurrent Test extends HttpServlet { …………Username = request.getParameter (username);Synchronized (this){Output = response.getWriter ();Try {Thread. Sleep (5000);} Catch (Interrupted Exception e){}output.println(用户名:+Username+
);}}}3、避免使用实例变量本实例中的线程安全问题是由实例变量造成的，只要在Servlet里面的任何方法里面都不使用实例变量，那么该Servlet就是线程安全的。
修正上面的Servlet代码，将实例变量改为局部变量实现同样的功能，代码如下：……Public class Concurrent Test extends HttpServlet {public void service (HttpServletRequest request, HttpServletResponseResponse) throws ServletException, IOException {Print Writer output;String username;Response.setContentType (text\\\/html; charset=gb2312);……}}对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。
但是，如果一个Servlet实现了SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。
SingleThreadModel在Servlet2.4中已不再提倡使用；同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大下降。
这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。
另外为保证主存内容和线程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。
所以在实际的开发中也应避免或最小化 Servlet 中的同步代码；在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。
从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。
小结Servlet的线程安全问题只有在大量的并发访问时才会显现出来，并且很难发现，因此在编写Servlet程序时要特别注意。
线程安全问题主要是由实例变量造成的,因此在Servlet中应避免使用实例变量。
如果应用程序设计无法避免使用实例变量，那么使用同步来保护要使用的实例变量，但为保证系统的最佳性能，应该同步可用性最小的代码路径。
一，servlet容器如何同时处理多个请求。
Servlet采用多线程来处理多个请求同时访问，Servelet容器维护了一个线程池来服务请求。
线程池实际上是等待执行代码的一组线程叫做工作者线程(Worker Thread)，Servlet容器使用一个调度线程来管理工作者线程(Dispatcher Thread)。
当容器收到一个访问Servlet的请求，调度者线程从线程池中选出一个工作者线程，将请求传递给该线程，然后由该线程来执行Servlet的service方法。
当这个线程正在执行的时候，容器收到另外一个请求，调度者线程将从池中选出另外一个工作者线程来服务新的请求，容器并不关系这个请求是否访问的是同一个Servlet还是另外一个Servlet。
当容器同时收到对同一Servlet的多个请求，那这个Servlet的service方法将在多线程中并发的执行。
二，Servlet容器默认采用单实例多线程的方式来处理请求，这样减少产生Servlet实例的开销，提升了对请求的响应时间。
对于Tomcat可以在server.xml中通过
就实现来说：调度者线程类所担负的责任如其名字，该类的责任是调度线程，只需要利用自己的属性完成自己的责任。
所以该类是承担了责任的，并且该类的责任又集中到唯一的单体对象中。
而其他对象又依赖于该特定对象所承担的责任，我们就需要得到该特定对象。
那该类就是一个单例模式的实现了。
三，如何开发线程安全的Servlet1，变量的线程安全：这里的变量指字段和共享数据(如表单参数值)。
a，将 参数变量 本地化。
多线程并不共享局部变量.所以我们要尽可能的在servlet中使用局部变量。
例如：String user = ;user = request.getParameter(user);b，使用同步块Synchronized，防止可能异步调用的代码块。
这意味着线程需要排队处理。
在使用同板块的时候要尽可能的缩小同步代码的范围，不要直接在sevice方法和响应方法上使用同步，这样会严重影响性能。
2,属性的线程安全：ServletContext，HttpSession，ServletRequest对象中属性ServletContext：（线程是不安全的）ServletContext是可以多线程同时读\\\/写属性的，线程是不安全的。
要对属性的读写进行同步处理或者进行深度Clone()。
所以在Servlet上下文中尽可能少量保存会被修改（写）的数据，可以采取其他方式在多个Servlet中共享，比方我们可以使用单例模式来处理共享数据。
HttpSession：（线程是不安全的）HttpSession对象在用户会话期间存在，只能在处理属于同一个Session的请求的线程中被访问，因此Session对象的属性访问理论上是线程安全的。
当用户打开多个同属于一个进程的浏览器窗口，在这些窗口的访问属于同一个Session，会出现多次请求，需要多个工作线程来处理请求，可能造成同时多线程读写属性。
这时我们需要对属性的读写进行同步处理：使用同步块Synchronized和使用读\\\/写器来解决。
ServletRequest：（线程是安全的）对于每一个请求，由一个工作线程来执行，都会创建有一个新的ServletRequest对象，所以ServletRequest对象只能在一个线程中被访问。
ServletRequest是线程安全的。
注意：ServletRequest对象在service方法的范围内是有效的，不要试图在service方法结束后仍然保存请求对象的引用。
3，使用同步的集合类：使用Vector代替ArrayList，使用Hashtable代替HashMap。
4，不要在Servlet中创建自己的线程来完成某个功能。
Servlet本身就是多线程的，在Servlet中再创建线程，将导致执行情况复杂化，出现多线程安全问题。
5，在多个servlet中对外部对象(比方文件)进行修改操作一定要加锁，做到互斥的访问。
四，SingleThreadModel接口javax.servlet.SingleThreadModel接口是一个标识接口，如果一个Servlet实现了这个接口，那Servlet容器将保证在一个时刻仅有一个线程可以在给定的servlet实例的service方法中执行。
将其他所有请求进行排队。
服务器可以使用多个实例来处理请求，代替单个实例的请求排队带来的效益问题。
服务器创建一个Servlet类的多个Servlet实例组成的实例池，对于每个请求分配Servlet实例进行响应处理，之后放回到实例池中等待下此请求。
这样就造成并发访问的问题。
此时,局部变量(字段)也是安全的，但对于全局变量和共享数据是不安全的，需要进行同步处理。
而对于这样多实例的情况SingleThreadModel接口并不能解决并发访问问题。
Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。
当客户端第一次请求某个Servlet时，Servlet容器将会根据web.xml配置文件实例化这个Servlet类。
当有新的客户端请求该Servlet时，一般不会再实例化该Servlet类，也就是有多个线程在使用这个实例。
这样，当两个或多个线程同时访问同一个Servlet时，可能会发生多个线程同时访问同一资源的情况，数据可能会变得不一致。
所以在用Servlet构建的Web应用时如果不注意线程安全的问题，会使所写的Servlet程序有难以发现的错误。
实例变量不正确的使用是造成Servlet线程不安全的主要原因。
下面针对该问题给出了三种解决方案并对方案的选取给出了一些参考性的建议。
1、实现 SingleThreadModel 接口该接口指定了系统如何处理对同一个Servlet的调用。
如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不会有两个线程被同时执行，当然也就不存在线程安全的问题。
这种方法只要将前面的Concurrent Test类的类头定义更改为：Public class Concurrent Test extends HttpServlet implements SingleThreadModel {…………}2、同步对共享数据的操作使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段，在本论文中的Servlet可以通过同步块操作来保证线程的安全。
同步后的代码如下：…………Public class Concurrent Test extends HttpServlet { …………Username = request.getParameter (username);Synchronized (this){Output = response.getWriter ();Try {Thread. Sleep (5000);} Catch (Interrupted Exception e){}output.println(用户名:+Username+);}}}3、避免使用实例变量本实例中的线程安全问题是由实例变量造成的，只要在Servlet里面的任何方法里面都不使用实例变量，那么该Servlet就是线程安全的。
修正上面的Servlet代码，将实例变量改为局部变量实现同样的功能，代码如下：……Public class Concurrent Test extends HttpServlet {public void service (HttpServletRequest request, HttpServletResponseResponse) throws ServletException, IOException {Print Writer output;String username;Response.setContentType (text\\\/html; charset=gb2312);……}}对上面的三种方法进行测试，可以表明用它们都能设计出线程安全的Servlet程序。
但是，如果一个Servlet实现了SingleThreadModel接口，Servlet引擎将为每个新的请求创建一个单独的Servlet实例，这将引起大量的系统开销。
SingleThreadModel在Servlet2.4中已不再提倡使用；同样如果在程序中使用同步来保护要使用的共享的数据，也会使系统的性能大大下降。
这是因为被同步的代码块在同一时刻只能有一个线程执行它，使得其同时处理客户请求的吞吐量降低，而且很多客户处于阻塞状态。
另外为保证主存内容和线程的工作内存中的数据的一致性，要频繁地刷新缓存,这也会大大地影响系统的性能。
所以在实际的开发中也应避免或最小化 Servlet 中的同步代码；在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。
从Java 内存模型也可以知道，方法中的临时变量是在栈上分配空间，而且每个线程都有自己私有的栈空间，所以它们不会影响线程的安全。
补充：servlet存在的多线程问题实例变量: 实例变量是在堆中分配的,并被属于该实例的所有线程共享，所以不是线程安全的.JSP系统提供的8个类变量:JSP中用到的OUT,REQUEST,RESPONSE,SESSION,CONFIG,PAGE,PAGECONXT是线程安全的,APPLICATION在整个系统内被使用,所以不是线程安全的.局部变量: 局部变量在堆栈中分配,因为每个线程都有它自己的堆栈空间,所以是线程安全的.静态类:静态类不用被实例化,就可直接使用,也不是线程安全的.外部资源:在程序中可能会有多个线程或进程同时操作同一个资源(如:多个线程或进程同时对一个文件进行写操作).此时也要注意同步问题. 使它以单线程方式执行,这时，仍然只有一个实例，所有客户端的请求以串行方式执行。
这样会降低系统的性能对于存在线程不安全的类,如何避免出现线程安全问题:1、采用synchronized同步。
缺点就是存在堵塞问题。
2、使用ThreadLocal(实际上就是一个HashMap),这样不同的线程维护自己的对象，线程之间相互不干扰。
ThreadLocal的设计首先看看ThreadLocal的接口：Object get() ; \\\/\\\/ 返回当前线程的线程局部变量副本 protected ObjectinitialValue(); \\\/\\\/ 返回该线程局部变量的当前线程的初始值 void set(Object value); \\\/\\\/ 设置当前线程的线程局部变量副本的值ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。
该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。
ThreadLocal中的确实实现直接返回一个null：protected Object initialValue() { return null; }ThreadLocal是如何做到为每一个线程维护变量的副本的呢
其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。
比如下面的示例实现：public class ThreadLocal{private Map values = Collections.synchronizedMap(new HashMap());public Object get(){Thread curThread = Thread.currentThread();Object o = values.get(curThread);if (o == null && !values.containsKey(curThread)){o = initialValue();values.put(curThread, o);}return o;}public void set(Object newValue){values.put(Thread.currentThread(), newValue);}public Object initialValue(){return null;}}当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。
ThreadLocal的使用如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号：public class SerialNum{\\\/\\\/ The next serial number to be assignedprivate static int nextSerialNum = 0;private static ThreadLocal serialNum = new ThreadLocal(){protected synchronized Object initialValue(){return new Integer(nextSerialNum++);}};public static int get(){return ((Integer) (serialNum.get())).intValue();}}SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：int serial = SerialNum.get(); 即可。
在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。
ThreadLocal与其它同步机制的比较ThreadLocal和其它同步机制相比有什么优势呢
ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。
这时该变量是多个线程共享的，使用这种同步机制需要很细致地分析在什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等等很多。
所有这些都是因为多个线程共享了资源造成的。
ThreadLocal就从另一个角度来解决多线程的并发访问，ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。
ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象的特定于线程的状态封装进ThreadLocal。
由于ThreadLocal中可以持有任何类型的对象，所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。
但随着新的Java版本（1.5）将模版的引入，新的支持模版参数的ThreadLocal
也可以减少强制类型转换，并将一些错误检查提前到了编译期，将一定程度地简化ThreadLocal的使用。
总结当然ThreadLocal并不能替代同步机制，两者面向的问题领域不同。
同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。
所以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程序，使程序更加易读、简洁。
ThreadLocal常见用途：存放当前session用户存放一些context变量，比如webwork的ActionContext存放session，比如spring hibernate orm的session例子：用 ThreadLocal 实现每线程 Singleton线程局部变量常被用来描绘有状态“单子”（Singleton） 或线程安全的共享对象，或者是通过把不安全的整个变量封装进 ThreadLocal，或者是通过把对象的特定于线程的状态封装进 ThreadLocal。
例如，在与数据库有紧密联系的应用程序中，程序的很多方法可能都需要访问数据库。
在系统的每个方法中都包含一个 Connection 作为参数是不方便的 — 用“单子”来访问连接可能是一个虽然更粗糙，但却方便得多的技术。
然而，多个线程不能安全地共享一个 JDBC Connection。
如清单 3 所示，通过使用“单子”中的 ThreadLocal，我们就能让我们的程序中的任何类容易地获取每线程 Connection 的一个引用。
这样，我们可以认为 ThreadLocal 允许我们创建每线程单子。
例：把一个 JDBC 连接存储到一个每线程 Singleton 中public class ConnectionDispenser {private static class ThreadLocalConnection extends ThreadLocal {public Object initialValue() {return DriverManager.getConnection(ConfigurationSingleton.getDbUrl());}}private ThreadLocalConnection conn = new ThreadLocalConnection();public static Connection getConnection() {return (Connection) conn.get();}}注意：理论上来说，ThreadLocal是的确是相对于每个线程，每个线程会有自己的ThreadLocal。
但是上面已经讲到，一般的应用服务器都会维护一套线程池。
因此，不同用户访问，可能会接受到同样的线程。
因此，在做基于TheadLocal时，需要谨慎，避免出现ThreadLocal变量的缓存，导致其他线程访问到本线程变量。
