多线程问题（双核CPU）

Question

废话不说，看程序说话
public class SynchonizedTest {
    public static void main(String[] args) throws InterruptedException {
        test1();
    }
      
    private static void test1() throws InterruptedException {
        ServerSafe client1 = new ServerSafe();
        ServerSafe client2 = new ServerSafe();
        
        client1.setName("user1");
        client2.setName("user2");
        
        client1.start();
        client2.start();
        
        Thread.sleep(8000);
        System.out.println("now the money in the bank is:" + Server.story);
    }
}class ServerSafe extends Thread {
    static int story = 3000;
    
    private synchronized void takeMoney() {
        System.out.println(currentThread().getName() +" comes.");
        int temp = story - 2000;
        if(temp>0) {
            for(int i = 0 ; i<10000; i++) {
                for(int j = 0 ; j<100000; j++) {
                    
                }
            }
            
            story -= 2000;
            System.out.println(currentThread().getName() + " get 2000 from server.");
        }
    }
    public  void  run() {
        takeMoney();
    }
}输出结果：
user1 comes.
user2 comes.
user1 get 2000 from server.
user2 get 2000 from server.
now the money in the bank is:3000疑问：同步方法失效？第一次发帖，分不多，望各路高手不吝赐教，洒家一定感恩于心！

Answer 1

这样好象是不会有效的吧
两个Thread操作两个不同的类,想想就应该跟同步没什么关系
放到runnable里面去吧

Answer 2

现简要说一下：
synchronized只对同一对象有效，就是这样理解吧：一个对象有且仅有一把锁，你的是不同的对象，两把锁，当然是不干扰的，下面是我的一点笔记：我的博客里还有很多相关的。A关键字synchronized每个java对象都有一把锁， 当有多个线程同时访问共享资源的时候， 需要Synchronize 来控制安全性， synchronize 分 synchronize 方法 和synchronize块，使用synchronize块时， 一定要显示的获得该对象的锁（如synchronize（object))而方法则不需要。java的内存模型是对每一个进程有一个主内存， 每个线程有自己的内存， 他们从主内存中取数据， 然后计算， 再存入主内存中。 并发问题如下：如果多个线程同事操作同一数据， A线程从主内存中取的I的值为1， 然后进行加1操作， 这时B线程也取I的值， 进行加2操作， 然后A存入2到主内存中， B也存入， 这样就覆盖了A的值（同数据库中的并发问题一样）。解决办法是用synchronize， 如用synchronized（I）。被synchronize 修饰的方法（块）把以下三步操作当成一个原子操作：取数据， 操作数据， 存数据。 我们知道原子操作是不可以被打断的， 所以其保证了数据一致性， 这样同一时间只有一个线程再执行， 对性能有一定的影响。这也是synchronize的第二个作用：保证统一时间只有一个线程再运行。 当实现SOCKET连接的时候经常用到.JAVA中规定对非FLOAT, LONG的原始类型的取和存操作为原子操作。 其实就是对一个字（32位）的取，存位原始操作， 因为FLOAT, LONG为两个字节的长度， 所以其取， 存为非原子操作。 如果想把他们也变为原子操作， 可以用VOLATILE关键字来修饰
使用方法：作用区域主要有两种：1.方法2.代码块被synchronized声明的方法被称为同步方法，被其修饰的代码块称为同步语句。无论是同步方法还是同步语句，只要声明为同步了，在同一时刻，同一个对象的同步XX是不可以被同时访问的，而不同对象之间的同步方法是互不干扰的。
具体实现（如下代码都在某个类定义中）：同步方法：Public synchronized void change() {//}
同步语句：（因为效率问题，有时考虑使用同步语句块）    Public void change() {Synchronized(this) {
}}这个同步语句是针对当前对象的，有时，我们就是想让一段代码同步，可能与当前对象并没什么关系，可以自定义同步的锁。如下：private byte[]  lock= new byte[0];
   Public void change() {Synchronized(lock) {
}}自定义锁注意事项：1必须是private，防止在类外部引用改变。2如果可能用到，重写get方法，返回对象的clone,而不是本身。其他用法：Synchronized除了可以作用于方法，代码块，还可以作用于静态方法，类，某个实例。但是都存在效率问题，一定要慎用。
Class Foo 　　{ 　　
public synchronizedstatic void methodAAA()// 同步的static 函数　　{ 　　
//….　　
} 　　 public void methodBBB() 　　{ 　　
synchronized(Foo.class)// class literal(类名称字面常量)　
　} }这样修饰后代表的是：统一时刻，被修饰部分只有一个对象可以运行，因为它的声明是针对类的。
2.wait()/notify()/notifyAll()

Answer 3

LZ锁定对象不是一个对象。所以不起作用。package synchronizedtest;public class Test { public static void main(String[] args) {
Thread t1 = new Thread(new TestThread("t1"));
Thread t2 = new Thread(new TestThread("t2"));
t1.start();
t2.start();
}

static class TestThread implements Runnable{
private static Object lock = new Object();
private String name;

public TestThread(String name){
this.name = name;
}

public void run() {
synMethod();
}

private void synMethod(){
synchronized(lock){
System.out.println(name + " is come in.");
Thread.yield();
System.out.println(name + " is out.");
}
}

}
}