新手求助，有关线程异步调度

Question

线程A 对数据库A进行相关操作；线程B对数据库B进行相关操作。
我想实现对先进行启动线程A，操作完后锁住线程A，然后启动线程B，对数据库B操作完后，锁住线程，再启动线程A。
应该怎么实现，最好可以给个简单的例子。

Answer 1

/**********************共享资源***************************/
/*This is created by jiangwh!2010-8-11下午01:10:56*/
package com.net.socket.Tcp;public class Share { public static final Object lock = new Object();
private boolean flag=false;
private static Share share = new Share();
public static Share getNewInstance(){
return share;
}
public synchronized boolean isFlag() {
return flag;
}
public synchronized void setFlag(boolean flag) {
this.flag = flag;
}
public static void main(String[] args) {
new Thread(new TA()).start();
new Thread(new TA()).start();
new Thread(new TA()).start();
new Thread(new TA()).start();
new Thread(new TA()).start();
new Thread(new TB()).start();
new Thread(new TB()).start();
new Thread(new TB()).start();
new Thread(new TB()).start();
new Thread(new TB()).start();
}

}
/************************线程A**************************************/
/*This is created by jiangwh!2010-8-11下午01:02:23*/
package com.net.socket.Tcp;public class TA implements Runnable {
private Share share = Share.getNewInstance();
private boolean flag = true;
public TA(boolean flag) {
this.flag = flag;
}
public TA() {}
@Override
public void run() {
// 操作数据库
while (flag) {
synchronized (Share.lock) {
if (!share.isFlag()) {
System.out.println(Thread.currentThread().getName()+" A --Deal With DataBase");
share.setFlag(true);
Share.lock.notifyAll();
} else {
try {
Share.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} }
}
}
}
/************************线程B**************************************/
/*This is created by jiangwh!2010-8-11下午01:10:44*/
package com.net.socket.Tcp;public class TB implements Runnable{ private Share share = Share.getNewInstance();
private boolean flag = true;
public TB() {}
public TB(boolean flag) {
this.flag = flag;
}
@Override
public void run() {
while(flag){
synchronized (Share.lock) {
if(share.isFlag()){
System.out.println(Thread.currentThread().getName()+" B --Deal With DataBase");
share.setFlag(false);
Share.lock.notifyAll();
}else{
try {
Share.lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

}
}
}

Answer 2

基本上可以这么实现，通过共享锁，来调度两个线程。MyObject o = new MyObject();//shared lockThread A = new MyThread1(o);
Thread B = new MyThread2(o);   A.start();
B.start();
//endpublic class MyObject {
public static final int A_STATE = 1;
public static final int B_STATE = 2;     int state = A_STATE;    public synchronized void setState(int a_or_b){
         this.state = a_or_b;
    }  public synchronized int getState(){
        return this.state;
    }
}public class MyThread1 extends Thread{
   MyObject object = null;
   public MyThread1(Object o){
       this.object = o;
   }
   
   @Override
   public void run(){
      while(! Thread.currentThread().interrupted() ){
          synchronized(object ){
            if(object.getState() != MyObject.A_STATE )
                object.wait();//try..catch..            if(object.getState() != MyObject.A_STATE )
                 continue();
            ....//访问数据库
                             object.setState(MyObject.B_STATE);
                object .notify();
             
          }
          
          
       }
   }
}public class MyThread2 extends Thread{
     .......//同上
   ...run(){
              ...//同上         synchronized(this.object){
               if(object.getState() != MyObject.B_STATE)
                      object.wait();//等待A，需要try..catch...
               
               if(object.getState() != MyObject.B_STATE)
                      continue();               ...... //访问数据库              object.setState(MyObject.A_STATE);              object.notify();//唤醒A         }
       }}
说实话，这很容易导致死锁。应该有更好的模型。

Answer 3

synchronized (Share.lock)这句是什么意思？

Answer 4

意思就是在线程执行至"synchronized"设定的区块时取得对象的锁定，这么一来其它线程暂时无法取得锁定，因此无法执行对象同步化区块，这个方式可以应用于您不想锁定整个方法区块，而只是想在共享数据在被线程存取时确保同步化时，由于只锁定方法中的某个区块，在执行完区块后即释放对对象的锁定，以便让其它线程有机会取得锁定，对对象进行操作，在某些时候会比较有效率。

Answer 5

我试一试:方法一:定义两个boolean静态的全局变量 messagea=true和messageb=false;并且启动A B线程
A线程run方法代码如下:
{
while(true){
while(!messagea);
//执行A代码程序;
messagea=false;
messageb=true;
}
}
B线程run方法代码如下:
{
while(true){
while(!messageb);
//执行A代码程序;
messageb=false;
messagea=true;
}
}方法二:B线程中调用A的wait方法,A结束之前调用B的wait方法，并执行自己的notify方法然后B结束之前调用A的wait方法并调用自己的notify方法

Answer 6

建议去看看Synchronize 的相关知识.和线程间的死锁问题.光看别人给的代码没什么收获的.

Answer 7

建议去看看Synchronize 的相关知识.和线程间的死锁问题.光看别人给的代码没什么收获的.线程，这个，主要自己要实践中总结。