经常看到介绍 ArrayList 和HashMap是异步，Vector和HashTable是同步,这里同步是线程安全的，异步不是线程安全的，举例说明:
当创建一个Vector对象时候，
Vector ve=new Vector();
ve.add("1");
当在多线程程序中，第一个线程调用修改对象ve的时候，就为其上了锁，其他线程只有等待。
当创建一个ArrayList对象时候，
ArrayList list=new ArrayList();
list.add("1");
当在多线程程序中，第一个线程调用修改对象list的时候，没有为其上锁，其他线程访问时就会报错。
eg：list.remove("1"),然后再由其他线程访问list对象的1时就会报错。
经常看到介绍 ArrayList 和HashMap是异步，Vector和HashTable是同步,这里同步是线程安全的，异步不是线程安全的，举例说明:
当创建一个Vector对象时候，
Vector ve=new Vector();
ve.add("1");
当在多线程程序中，第一个线程调用修改对象ve的时候，就为其上了锁，其他线程只有等待。
当创建一个ArrayList对象时候，
ArrayList list=new ArrayList();
list.add("1");
当在多线程程序中，第一个线程调用修改对象list的时候，没有为其上锁，其他线程访问时就会报错。
eg：list.remove("1"),然后再由其他线程访问list对象的1时就会报错。
java 异步与同步应用
所谓异步输入输出机制，是指在进行输入输出处理时，不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞（None Blocking）。
网上有很多网友用很通俗的比喻 把同步和异步讲解的很透彻 转过来
举个例子：普通B/S模式（同步）AJAX技术（异步）
同步：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事
异步: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕
同步就是你叫我去吃饭，我听到了就和你去吃饭；如果没有听到，你就不停的叫，直到我告诉你听到了，才一起去吃饭。
异步就是你叫我，然后自己去吃饭，我得到消息后可能立即走，也可能等到下班才去吃饭。
所以，要我请你吃饭就用同步的方法，要请我吃饭就用异步的方法，这样你可以省钱。
以通讯为例
同步:发送一个请求,等待返回,然后再发送下一个请求
异步:发送一个请求,不等待返回,随时可以再发送下一个请求
并发:同时发送多个请求
下面再转一段关于java异步应用的文章
用异步输入输出流编写Socket进程通信程序
在Merlin中加入了用于实现异步输入输出机制的应用程序接口包：java.nio（新的输入输出包，定义了很多基本类型缓冲(Buffer)）， java.nio.channels(通道及选择器等，用于异步输入输出)，java.nio.charset（字符的编码解码）。通道 (Channel)首先在选择器(Selector)中注册自己感兴趣的事件，当相应的事件发生时，选择器便通过选择键(SelectionKey)通知已注册的通道。然后通道将需要处理的信息，通过缓冲（Buffer）打包，编码/解码,完成输入输出控制。
这里主要介绍ServerSocketChannel和 SocketChannel.它们都是可选择的(selectable)通道，分别可以工作在同步和异步两种方式下（注意，这里的可选择不是指可以选择两种工作方式，而是指可以有选择的注册自己感兴趣的事件）。可以用channel.configureBlocking(Boolean )来设置其工作方式。与以前版本的API相比较，ServerSocketChannel就相当于ServerSocket (ServerSocketChannel封装了ServerSocket),而SocketChannel就相当于Socket （SocketChannel封装了Socket）。当通道工作在同步方式时，编程方法与以前的基本相似，这里主要介绍异步工作方式。
所谓异步输入输出机制，是指在进行输入输出处理时，不必等到输入输出处理完毕才返回。所以异步的同义语是非阻塞（None Blocking）。在服务器端，ServerSocketChannel通过静态函数open()返回一个实例serverChl。然后该通道调用 serverChl.socket().bind()绑定到服务器某端口，并调用register（Selector sel, SelectionKey.OP_ACCEPT）注册OP_ACCEPT事件到一个选择器中（ServerSocketChannel只可以注册 OP_ACCEPT事件）。当有客户请求连接时，选择器就会通知该通道有客户连接请求，就可以进行相应的输入输出控制了；在客户端，clientChl实例注册自己感兴趣的事件后（可以是OP_CONNECT,OP_READ,OP_WRITE的组合），调用clientChl.connect (InetSocketAddress )连接服务器然后进行相应处理。注意，这里的连接是异步的，即会立即返回而继续执行后面的代码。
选择器（Selector）的作用是：将通道感兴趣的事件放入队列中，而不是马上提交给应用程序，等已注册的通道自己来请求处理这些事件。换句话说，就是选择器将会随时报告已经准备好了的通道，而且是按照先进先出的顺序。那么，选择器是通过什么来报告的呢？选择键(SelectionKey)。选择键的作用就是表明哪个通道已经做好了准备，准备干什么。你也许马上会想到，那一定是已注册的通道感兴趣的事件。不错，例如对于服务器端serverChl来说，可以调用key.isAcceptable()来通知serverChl有客户端连接请求。相应的函数还有： SelectionKey.isReadable(),SelectionKey.isWritable()。一般的，在一个循环中轮询感兴趣的事件（具体可参照下面的代码）。如果选择器中尚无通道已注册事件发生，调用Selector.select()将阻塞，直到有事件发生为止。另外，可以调用 selectNow()或者select(long timeout)。前者立即返回，没有事件时返回0值；后者等待timeout时间后返回。一个选择器最多可以同时被63个通道一起注册使用。
下面是用异步输入输出机制实现的客户/服务器实例程序�D�D程序清单1（限于篇幅，只给出了服务器端实现，读者可以参照着实现客户端代码）：
1. public class NBlockingServer {
2. int port = 8000;
3. int BUFFERSIZE = 1024;
4. Selector selector = null;
5. ServerSocketChannel serverChannel = null;
6. HashMap clientChannelMap = null;//用来存放每一个客户连接对应的套接字和通道
7.
8. public NBlockingServer( int port ) {
9. this.clientChannelMap = new HashMap();
10. this.port = port;
11. }
12.
13. public void initialize() throws IOException {
14. //初始化，分别实例化一个选择器，一个服务器端可选择通道
15. this.selector = Selector.open();
16. this.serverChannel = ServerSocketChannel.open();
17. this.serverChannel.configureBlocking(false);
18. InetAddress localhost = InetAddress.getLocalHost();
19. InetSocketAddress isa = new InetSocketAddress(localhost, this.port );
20. this.serverChannel.socket().bind(isa);//将该套接字绑定到服务器某一可用端口
21. }
22. //结束时释放资源
23. public void finalize() throws IOException {
24. this.serverChannel.close();
25. this.selector.close();
26. }
27. //将读入字节缓冲的信息解码
28. public String decode( ByteBuffer byteBuffer ) throws
29. CharacterCodingException {
30. Charset charset = Charset.forName( "ISO-8859-1" );
31. CharsetDecoder decoder = charset.newDecoder();
32. CharBuffer charBuffer = decoder.decode( byteBuffer );
33. String result = charBuffer.toString();
34. return result;
35. }
36. //监听端口，当通道准备好时进行相应操作
37. public void portListening() throws IOException, InterruptedException {
38. //服务器端通道注册OP_ACCEPT事件
39. SelectionKey acceptKey =this.serverChannel.register( this.selector,
40. SelectionKey.OP_ACCEPT );
41. //当有已注册的事件发生时,select()返回值将大于0
42. while (acceptKey.selector().select() > 0 ) {
43. System.out.println("event happened");
44. //取得所有已经准备好的所有选择键
45. Set readyKeys = this.selector.selectedKeys();
46. //使用迭代器对选择键进行轮询
47. Iterator i = readyKeys.iterator();
48. while (i.hasNext()) {
49. SelectionKey key = (SelectionKey)i.next();
50. i.remove();//删除当前将要处理的选择键
51. if ( key.isAcceptable() ) {//如果是有客户端连接请求
52. System.out.println("more client connect in!");
53. ServerSocketChannel nextReady =
54. (ServerSocketChannel)key.channel();
55. //获取客户端套接字
56. Socket s = nextReady.accept();
57. //设置对应的通道为异步方式并注册感兴趣事件
58. s.getChannel().configureBlocking( false );
59. SelectionKey readWriteKey =
60. s.getChannel().register( this.selector,
61. SelectionKey.OP_READ|SelectionKey.OP_WRITE );
62. //将注册的事件与该套接字联系起来
63. readWriteKey.attach( s );
64. //将当前建立连接的客户端套接字及对应的通道存放在哈希表//clientChannelMap中
65. this.clientChannelMap.put( s, new
66. ClientChInstance( s.getChannel() ) );
67. }
68. else if ( key.isReadable() ) {//如果是通道读准备好事件
69. System.out.println("Readable");
70. //取得选择键对应的通道和套接字
71. SelectableChannel nextReady =
72. (SelectableChannel) key.channel();
73. Socket socket = (Socket) key.attachment();
74. //处理该事件，处理方法已封装在类ClientChInstance中
75. this.readFromChannel( socket.getChannel(),
76. (ClientChInstance)
77. this.clientChannelMap.get( socket ) );
78. }
79. else if ( key.isWritable() ) {//如果是通道写准备好事件
80. System.out.println("writeable");
81. //取得套接字后处理，方法同上
82. Socket socket = (Socket) key.attachment();
83. SocketChannel channel = (SocketChannel)
84. socket.getChannel();
85. this.writeToChannel( channel,"This is from server!");
86. }
87. }
88. }
89. }
90. //对通道的写操作
91. public void writeToChannel( SocketChannel channel, String message )
92. throws IOException {
93. ByteBuffer buf = ByteBuffer.wrap( message.getBytes() );
94. int nbytes = channel.write( buf );
95. }
96. //对通道的读操作
97. public void readFromChannel( SocketChannel channel, ClientChInstance clientInstance )
98. throws IOException, InterruptedException {
99. ByteBuffer byteBuffer = ByteBuffer.allocate( BUFFERSIZE );
100. int nbytes = channel.read( byteBuffer );
101. byteBuffer.flip();
102. String result = this.decode( byteBuffer );
103. //当客户端发出”@exit”退出命令时，关闭其通道
104. if ( result.indexOf( "@exit" ) >= 0 ) {
105. channel.close();
106. }
107. else {
108. clientInstance.append( result.toString() );
109. //读入一行完毕，执行相应操作
110. if ( result.indexOf( ""n" ) >= 0 ){
111. System.out.println("client input"+result);
112. clientInstance.execute();
113. }
114. }
115. }
116. //该类封装了怎样对客户端的通道进行操作，具体实现可以通过重载execute()方法
117. public class ClientChInstance {
118. SocketChannel channel;
119. StringBuffer buffer=new StringBuffer();
120. public ClientChInstance( SocketChannel channel ) {
121. this.channel = channel;
122. }
123. public void execute() throws IOException {
124. String message = "This is response after reading from channel!";
125. writeToChannel( this.channel, message );
126. buffer = new StringBuffer();
127. }
128. //当一行没有结束时，将当前字窜置于缓冲尾
129. public void append( String values ) {
130. buffer.append( values );
131. }
132. }
133.
134.
135. //主程序
136. public static void main( String[] args ) {
137. NBlockingServer nbServer = new NBlockingServer(8000);
138. try {
139. nbServer.initialize();
140. } catch ( Exception e ) {
141. e.printStackTrace();
142. System.exit( -1 );
143. }
144. try {
145. nbServer.portListening();
146. }
147. catch ( Exception e ) {
148. e.printStackTrace();
149. }
150. }
151. }
152.
从以上程序段可以看出，服务器端没有引入多余线程就完成了多客户的客户/服务器模式。该程序中使用了回调模式(CALLBACK)，细心的读者应该早就看出来了。需要注意的是，请不要将原来的输入输出包与新加入的输入输出包混用，因为出于一些原因的考虑，这两个包并不兼容。即使用通道时请使用缓冲完成输入输出控制。该程序在Windows2000,J2SE1.4下，用telnet测试成功
synchronized的一个简单例子
public class TextThread
{
/**
* @param args
*/
public static void main(String[] args)
{
// TODO 自动生成方法存根
TxtThread tt = new TxtThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}
class TxtThread implements Runnable
{
int num = 100;
String str = new String();
public void run()
{
while (true)
{
synchronized(str)
{
if (num>0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
e.getMessage();
}
System.out.println(Thread.currentThread().getName()+ "this is "+ num--);
}
}
}
}
}
上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)
Java对多线程的支持与同步机制深受大家的喜爱，似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如何？――还得对synchronized关键字的作用进行深入了解才可定论。
总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
在进一步阐述之前，我们需要明确几点：
A．无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。
B．每个对象只有一个锁（lock）与之相关联。
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
接着来讨论synchronized用到不同地方对代码产生的影响：
假设P1、P2是同一个类的不同对象，这个类中定义了以下几种情况的同步块或同步方法，P1、P2就都可以调用它们。
1． 把synchronized当作函数修饰符时，示例代码如下：
Public synchronized void methodAAA()
{
//….
}
这也就是同步方法，那这时synchronized锁定的是哪个对象呢？它锁定的是调用这个同步方法对象。也就是说，当一个对象P1在不同的线程中执行这个同步方法时，它们之间会形成互斥，达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了synchronized关键字的方法。
上边的示例代码等同于如下代码：
public void methodAAA()
{
synchronized (this) // (1)
{
//…..
}
}
(1)处的this指的是什么呢？它指的就是调用这个方法的对象，如P1。可见同步方法实质是将synchronized作用于object reference。――那个拿到了P1对象锁的线程，才可以调用P1的同步方法，而对P2而言，P1这个锁与它毫不相干，程序也可能在这种情形下摆脱同步机制的控制，造成数据混乱：（
2．同步块，示例代码如下：
public void method3(SomeObject so)
{
synchronized(so)
{
//…..
}
}
这时，锁就是so这个对象，谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以这样写程序，但当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的instance变量（它得是一个对象）来充当锁：
class Foo implements Runnable
{
private byte[] lock = new byte[0]; // 特殊的instance变量
Public void methodA()
{
synchronized(lock) { //… }
}
//…..
}
注：零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
3．将synchronized作用于static 函数，示例代码如下：
Class Foo
{
public synchronized static void methodAAA() // 同步的static 函数
{
//….
}
public void methodBBB()
{
synchronized(Foo.class) // class literal(类名称字面常量)
}
}
代码中的methodBBB()方法是把class literal作为锁的情况，它和同步的static函数产生的效果是一样的，取得的锁很特别，是当前调用这个方法的对象所属的类（Class，而不再是由这个Class产生的某个具体对象了）。
记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样，不能用P1.getClass()来达到锁这个Class的目的。P1指的是由Foo类产生的对象。
可以推断：如果一个类中定义了一个synchronized的static函数A，也定义了一个synchronized 的instance函数B，那么这个类的同一对象Obj在多线程中分别访问A和B两个方法时，不会构成同步，因为它们的锁都不一样。A方法的锁是Obj这个对象，而B的锁是Obj所属的那个Class。
小结如下：
搞清楚synchronized锁定的是哪个对象，就能帮助我们设计更安全的多线程程序。
还有一些技巧可以让我们对共享资源的同步访问更加安全：
1． 定义private 的instance变量+它的 get方法，而不要定义public/protected的instance变量。如果将变量定义为public，对象在外界可以绕过同步方法的控制而直接取得它，并改动它。这也是JavaBean的标准实现方式之一。
2． 如果instance变量是一个对象，如数组或ArrayList什么的，那上述方法仍然不安全，因为当外界对象通过get方法拿到这个instance对象的引用后，又将其指向另一个对象，那么这个private变量也就变了，岂不是很危险。 这个时候就需要将get方法也加上synchronized同步，并且，只返回这个private对象的clone()――这样，调用端得到的就是对象副本的引用了。
转自http://blog.csdn.net/tuwen/archive/2007/09/12/1782644.aspx
1231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
