我想了解java和多线程中的Singleton类

Question

我使Bean成为一个单例类，其中我使用Bean的单例对象为bean.threadA和ThreadB设置了setter和getter。我希望ThreadA应该先执行它的任务，然后ThreadB应该开始执行它。我变得不一致。我怀疑我的代码是否不正确，或者如何让我的代码完全线程安全。希望合作。

public class Test { 
    public static void main(String args[]) 
    { 
     Bean bean = Bean.getInstance(); 
     new ThreadA(bean); 
     new ThreadB(bean); 
    } 
} 
class Bean 
{ 
    private static Bean instance = null; 
    protected Bean() { 
     // TODO Auto-generated constructor stub 
    } 
    int x; 
    public static Bean getInstance() 
    { 
     if(instance==null) 
     { 
      instance=new Bean(); 
      synchronized (instance) { 
       instance=new Bean(); 

      } 
     } 
     return instance; 
    } 
    public synchronized int getX() { 
     return x; 
    } 

    public synchronized void setX(int x) { 
     this.x = x; 
    } 

} 
class ThreadA extends Thread 
{ 
    Bean b; 
    public ThreadA(Bean b) { 
     this.start(); 
     this.b=b; 
    } 
    @Override 
    public void run() { 
     for (int i=1;i<=10;i++) 
     { 
      this.b.setX(i); 
      System.out.println(Thread.currentThread().getName() + " "+this.b.getX()); 

     } 
    } 
} 

class ThreadB extends Thread 
{ 
    Bean b; 
    public ThreadB(Bean b) { 
     this.start(); 
     this.b=b; 
    } 
    @Override 
    public void run() { 
     for (int i=1;i<=10;i++) 
     { 
      this.b.setX(i); 
      System.out.println(Thread.currentThread().getName() +" "+ this.b.getX()); 
     } 
    } 
} 

线程0 1线程0 2线程0 3线程0 4线程0 5线程0 6线程1 1线程0 7线程1 2主题-1 3线程1 4 Thread-1 5 Thread-0 8 Thread-1 6 Thread-1 7 Thread-1 8 Thread-1 9 Thread-1 10 Thread-0 9 Thread-0 10

我得到的结果与上面不一致。我想我的Thread-0是ThreadA应该首先执行任务，然后ThreadB = Thread-1应该启动它的执行。

/////////////////////////////我改变的代码开始后面

package p1; 

public class T { 
    public static void main(String args[]) 
    { 
     Bean1 bean = Bean1.getBean1(); 

     new ThreadA(bean); 
    // bean.lock(true); 
     new ThreadB(bean); 
    } 
} 
class Bean1 
{ 
    private static Bean1 instance = null; 
    static boolean threadAFinished=false; 
    private Bean1() { 
    } 
    private boolean beanLocked; 

    synchronized public void lock (boolean b) { 
     if(b) 
     { 
      try { 
       wait(); 
      } catch (InterruptedException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
     } 

     beanLocked=b; 
    } 
    synchronized public boolean getLock() 
    { 
     if(!beanLocked) 
     { 
      notify(); 
     } 

     return beanLocked; 
    } 
    int x; 
    public static Bean1 getBean1() { 
     if (instance==null) { 
      instance=new Bean1(); 
     } 
     return instance; 
    } 
    public int getX() { 

     return x; 
    } 

    public void setX(int x) { 

     this.x = x; 
    } 
} 
    class ThreadA implements Runnable { 
     Bean1 b; 
     public ThreadA(Bean1 b) { 
      this.b=b; 
     new Thread (this).start(); // run() uses b, set it before starting the thread 

     } 
     @Override 
     public void run() { 
      for (int i=1;i<=10;i++) { 
       b.setX(i); 
       System.out.println(Thread.currentThread().getName() + " "+b.getX()); 

     } 
      b.threadAFinished=true; 
      b.lock(false); 
     b.getLock(); 
    } 

    } 

    class ThreadB implements Runnable { 
     Bean1 b; 
     public ThreadB(Bean1 b) { 
      this.b=b; 
      new Thread(this).start(); 

     } 
     @Override 
     public void run() { 
     if(!b.threadAFinished) 
     { 
     b.lock(true); 
     } 
      for (int i=1;i<=10;i++) { 
       b.setX(i); 
       System.out.println(Thread.currentThread().getName() +" "+ b.getX()); 
    } 
      } 
     } 

Answer 1

这里有2个问题 - 创建一个单独的类和线程同步。此外，我认为你正在使用一些不必要的这个和同步的关键字。我写了一个快速而且脏的代码编辑，希望这有助于。

public class P4 { 

    public static void main(String args[]) 
    { 
     Bean bean = Bean.getBean(); 
     new ThreadA(bean); 
    bean.lock(true, true); 
     new ThreadB(bean); 
    } 
} 

class Bean 
{ 
    private static Bean instance = null; 
    private Bean() { 
    } 

    int x; 
    public static Bean getBean() { 
     if (instance==null) { 
      instance=new Bean(); 
     } 
     return instance; 
    } 

    private boolean beanLocked; 
    synchronized public boolean lock (boolean b, boolean l) { 
    if (b) { 
     beanLocked = l; 
     notify(); 
    } else { 
     while (beanLocked) { 
     try { 
      wait(); 
     } catch (InterruptedException ex) { 
    }}} 
    return beanLocked; 
    } 

    public int getX() { 
     return x; 
    } 

    public void setX(int x) { 
     this.x = x; 
    } 

} 

class ThreadA implements Runnable { 
    Bean b; 
    public ThreadA(Bean b) { 
     this.b=b; 
    new Thread (this).start(); // run() uses b, set it before starting the thread 
    } 
    @Override 
    public void run() { 
     for (int i=1;i<=10;i++) { 
      b.setX(i); 
      System.out.println(Thread.currentThread().getName() + " "+b.getX()); 

    } 
    b.lock(true, false); 
}} 

class ThreadB implements Runnable { 
    Bean b; 
    public ThreadB(Bean b) { 
     this.b=b; 
     new Thread(this).start(); 
    } 
    @Override 
    public void run() { 
    b.lock(false, false); // Dont care about 2nd argument 
     for (int i=1;i<=10;i++) { 
      b.setX(i); 
      System.out.println(Thread.currentThread().getName() +" "+ b.getX()); 
}}}