多线程的同步问题

Question

把你的方法加上同步关键字synchronous，不行吗？

Answer 1

你说的是synchronized关键字吧，这种方法好像只能保证对一个静态方法的同步

Answer 2

对不起，是synchronized,
他不仅可一锁定对象，还可以锁定某个动作。我想你可以在你的多线程访问各静态方法时加入一个同样的锁定动作的语句。如：
在你的多线程类中需要访问同步test类中的静态方法时，（不妨设有一个为getflag()方法）：
synchronized(test.getflag()){      //凡是要访问到test类的静态方法时同步此动作
...                    //访问test类的静态方法。
}看有否帮助。

Answer 3

使用flag的方法我也想过，不过至少要两个方法setFlag()和getFlag()，这两个方法之间怎么同步呢？

Answer 4

用volatile类型变量可以保证该变量只会任意时刻只被一个函数调用。
然后把该变量设为flag就可以了。

Answer 5

我想你弄错我的意思了，我并不是要用flag来控制，而是通过同步访问某一个方法（这里假设为test.getflag()这个方法）来控制。
这么说吧，在多线程类中，所有在访问test类的静态方法时，先要同步做一个访问某一个其他的方法的操作，通过这个瓶颈控制其他静态方法的访问。
不知说的是否清楚。

Answer 6

to lmy2000:
    我知道你的意思了，谢谢。
    呆会儿再给你加分，再看看其他人还有什么方法。    用flag来控制的方法我有这么一个思路，不知道对不对：
把flag放在静态类中，然后给静态类加一个用synchronized关键字同步的方法operate_flag(int flag_value,int mode)，通过mode的设定来标志对flag的操作是set还是get，这样无论
是set还是get都能同步了。

Answer 7

to lmy2000:
    仔细一想上边你的说法有问题：getflag()方法获得某个资源之后，怎么把它释放？getflag()方法什么时候执行完毕？    supersonics(落叶狂风)的方法不错。

Answer 8

我这样想的，不知能不能达到你的要求
//abc.java
class SyncObject {
    private static boolean flag ＝ false;
    public static void setFlag(boolean flag) {
        this.flag = flag;
    }
    public static boolean getFlag() {
        return flag
    }
}   public class abc {
    public static final SyncObject syncObject;
    public static void methodA() {    
        //在方法头同步syncObject,检查
        if(syncObject.getFlag()) {
            synchronized(syncObject) {  
                syncObject.wait();
                syncObject(true);
            }
        } else {         
            synchronized(syncObject) {  
                syncObject(true);
            }
        }
        //在这里写你的方法内容
        .....
        synchronized(syncObject) {
            syncObject.setFlag(false);
            syncObject.notify();
       }
   }
}  
          

Answer 9

to needle:
    非常感谢你的解答!
    不过我觉得class abc 中设置flag的方法调用应该是syncObject.setFlag(true)吧，你怎么用syncObject(true)呢？

Answer 10

很抱歉，你还是没有明白我的想法。
我并不是锁定具体的资源，其实我只是锁定了某个公用方法的执行：class test{
    public static void SyncMethod(){}   //用来锁定的公用方法
    public static void method1() {        //只能同步访问的静态方法1
        ...
    }
    public static void method2() {         //只能同步访问的静态方法2
       ...
    }
...
}  public class abc {
    public  void methodA() {    
        //在访问前同步锁定（对每一个test中的静态方法同样，除SyncMethod()方法）
            synchronized(test.SyncMethod()) {  
             test.method1();
        }　　　//在此释放方法的锁定
     ...　　
　　　　　　//在访问前同步锁定（对每一个test中的静态方法同样，除SyncMethod()方法）　
            synchronized(test.SyncMethod()) {  
             test.method2();
        }
    ...
           }  
这样在class abc 中，对test类中的方法method1,method2只能一个个的访问，不管你有多少个线程同时执行。

Answer 11

to lmy2000:
    谢谢！只好下次给你分啦。