这里的同步只对单个Java应用程序来说，至于数据库同步，文件同步等就不是这里讨论的问题了。
同步和多线程的关系
1.没有多线程环境就不需要同步。
2.即使有多线程环境也不一定需要同步。
为什么要同步：
为了防止多个线程对同一数据的修改，所以需要同步，否则会造成数据不一致。
Java提供了非常方便的多线程支持，所以说同步问题比较普遍，尤其是Servlet和
JSP的线程安全问题特别明显。
http://blog.csdn.net/treeroot/archive/2004/09/03/93881.aspx
同步的实质：
Java同步其实就是获得对象的同步锁，其他线程就只能等待。我们的大部分程序都
不是线程安全的，因为没有进行同步，而且我们没有必要，因为大部分情况根本没
有多线程环境。
只举一个例子说明同步的实质。
代码1：
class SynTest{
synchronized static method(){
//这个方法是同步的方法，每次只有一个线程可以进来
System.out.println("begin");
try{Thread.sleep(2000);}
System.out.println("end");
}
public static void main(String[] args){
//启动10个线程，这里用了匿名类，因为确实方便不少。
for(int i=0;i<10;i++){
new Thread(){
public void run(){
method();
}
}.start();
}
}
}
很容易看到每个线程必须等待前一个线程退出方法method后才可以进去。
上面的同步方法可以有另外的两种等价方式：
代码2：
class SynTest{
static method(){
synchronized(SynTest.class){
//这个方法虽然不是同步的方法，但是每次只有一个线程可以进到同步块
System.out.println("begin");
try{Thread.sleep(2000);}
System.out.println("end");
}
}
public static void main(String[] args){
//启动10个线程，这里用了匿名类，因为确实方便不少。
for(int i=0;i<10;i++){
new Thread(){
public void run(){
method();
}
}.start();
}
}
}
代码3：
class SynTest{
private static Object lock=new Object();
static method(){
synchronized(lock){
//这个方法用一个专门的对象作为锁。
System.out.println("begin");
try{Thread.sleep(2000);}
System.out.println("end");
}
}
public static void main(String[] args){
//启动10个线程，这里用了匿名类，因为确实方便不少。
for(int i=0;i<10;i++){
new Thread(){
public void run(){
method();
}
}.start();
}
}
}
其实上面三种情况基本上是等价的，不过第三种方式很常见，估计会有性能上的提
高吧，毕竟锁定一个小对象看起来比锁定一个大对象容易一点。
上面的是静态方法，如果是非静态的话，代码2的表现为 synchronized(this)。
这里先说明一点，同步和是否线程安全和方法是否是静态的一点关系都没有。
如果判断一个类或者一个方法是否线程安全的呢?
假设一个类没有提供直接修改成员变量的操作，也就是算只能通过方法修改
对象。我们很容易得出结论，只有所有的方法是线程安全的，这个类才是线程
安全的。那么如何判断一个方法是否线程安全的，只有看说明文档或者阅读源码了
，不过可以肯定的说大部分都不是线程安全的，从方法声明是看不出来的。
class Math{
public static int safePow(int x,int y){//假设y大于0
int res=x;
for(int i=1;i<y;i++) res*=x;
return res;
}
public static int unsafePow(int x,int y){
pow=y;
return pow(x);
}
private static int pow;
private static int pow(int x){
int res=x;
for(int i=1;i<pow;i++) res*=x;
return res;
}
}
我都不知道怎么回举这么无聊的例子，而且我发现这个问题脑子里很清楚，却很难
表达清楚，看一下两个线程调用unsafePow的例子。
Thread1： unsafePow(3,3);
Thread2: unsafePow(2,2);
假设Thread1执行到 pow=y;进入方法pow(int x);
此时pow=3;
然后Thread2执行pow=y; 进入方法pow(int x);
此时pow=2;
然后线程1执行pow(int x)方法应该等到的是3的2次方，导致错误，所以说
这个方法不是线程安全的。
线程安全的关键就是对成员变量的修改(类变量或者实例变量，两者在这里都是
一样的),而且对于访问方法同样存在线程安全问题。
我们知道Hashtable是线程安全的，因为所有的方法都同步了，也就是说最多只能同
时有一个线程对Hashtable操作，那么我们认为它是线程安全的。那么假设它的size()方法不同步，
那就有可能你调用size方法还没有返回，一个线程又添加了一个数据，这个时候你读取到的值应该是正确
的值，但是这个size方法还没有返回，又一个线程删除了一个数据，这个时候你返回的就是一个错误的大小了。
Hashtable也需要同步，当然Hashtable是线程安全的，Java文档也有说明，但是不
等于线程安全就不要同步压。
public class SynHashtable{
public static void main(String[] args)
{
final Hashtable ht=new Hashtable();
ht.put(new Object(),"Quick to Death");
new Thread(){
public void run(){
while(true){
if(ht.size()<10){
ht.put(new
Object(),"object");
}
else{
ht.clear();
}
}
}
}.start();
new Thread(){
public void run(){
unsafe(ht);
}
}.start();
}
static void unsafe(Hashtable ht){
while(true){
//synchronized(ht){
Iterator it=ht.values().iterator();
while(it.hasNext())
System.out.println(it.next());
}
//}
}
}
如果不同步的话很快就会崩溃。
建议多看看多线程安全问题 举例：买票问题。
public class Ticket implements Runnable
{
//定义100张票
private int tickets = 100;
@Override
public void run()
{
while(true)
{
synchronized(this){
if(tickets>0)
{
try{
Thread.sleep(10);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖出第"+(tickets--)+"张票");
}
}
}
}
}
public class Test
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t,"窗口1");
Thread t2 = new Thread(t,"窗口2");
Thread t3 = new Thread(t,"窗口3");
Thread t4 = new Thread(t,"窗口4");
t1.start();
t2.start();
t3.start();
t4.start();
}
}
|
收藏
淘帖
踩
