Java 两个线程中的公共数据

我想要两条线。一个将递增我的变量，另一个将在递增后在屏幕上显示它

我想使用

wait（）

和

notifyAll（）

函数来实现这一点，但我遇到了一些问题

我已经编写了这段代码，但它在某个点停止工作（它只显示第一个和最后一个数字：1和10）

公共类TestClass{
静态int x=0；
公共静态对象锁=新对象（）；
公共静态void main（字符串[]args）{
线程t1=新线程（新的可运行线程（）{
公开募捐{
试一试{
对于（int i=0；i<10；i++）{
已同步（锁定）{
lock.wait（）；
系统输出println（x）；
}
}
} 
捕捉（中断异常e）{
e、 printStackTrace（）；
}           
}
});
t1.start（）；
线程t2=新线程（新可运行（）{
公开募捐{
对于（int i=0；i<10；i++）{
已同步（锁定）{
x++；
lock.notifyAll（）；
}
}
}
});
t2.start（）；
}
}

我尝试在第一个线程中添加额外的

notifyAll（）

，在第二个线程中添加

wait（）

（

t2

），但仍然不起作用。我如何才能做到这一点？

来自：

唤醒的线程将无法继续，直到当前 线程放弃此对象上的锁定。觉醒的线程将 以通常的方式与可能存在的任何其他线程竞争 积极竞争在该对象上同步；例如 觉醒的线程在存在时没有可靠的特权或劣势 锁定此对象的下一个线程

您刚刚唤醒的线程不能保证立即获得锁，因此您可以让调用notifyAll（）的循环在另一个线程被唤醒之前运行其所有迭代

如果您想让他们轮流，一种方法是让每个人轮流等待：

唤醒的线程将无法继续，直到当前 线程放弃此对象上的锁定。觉醒的线程将 以通常的方式与可能存在的任何其他线程竞争 积极竞争在该对象上同步；例如 觉醒的线程在存在时没有可靠的特权或劣势 锁定此对象的下一个线程

您刚刚唤醒的线程不能保证立即获得锁，因此您可以让调用notifyAll（）的循环在另一个线程被唤醒之前运行其所有迭代

---

如果你想让他们轮流，一种方法是让每个人轮流等待。下面是一个有效的解决方案。关键在于添加一个额外的标志，该标志将指示写入线程是否具有写入权限。注意锁对象上的

final

，这是一种良好的做法

public class TestClass
{
    private static int x = 0;
    private static final Object lock = new Object();  
    private static boolean canWrite = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                try {
                    for(int i = 0; i < 10; i++)
                    {  
                        synchronized(lock)
                        {                            
                            if(!canWrite)                            
                                lock.wait();
                            System.out.println(x);
                            canWrite = false;
                            lock.notify();
                        }
                    }                    
                } 
                catch (InterruptedException e) {}
            }
        });        

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    for(int i = 0; i < 10; i++)
                    {                                                
                        synchronized(lock)
                        {                                                              
                            x++;
                            canWrite = true;
                            lock.notify();
                            lock.wait();
                        }
                    }                            
                } catch (InterruptedException ex) {}                                                                        
            }
        });
        t1.start();        
        t2.start();
    }
}

公共类TestClass
{
私有静态int x=0；
私有静态最终对象锁=新对象（）；
私有静态布尔值canWrite=false；
公共静态void main（字符串[]args）{
线程t1=新线程（新的可运行线程（）{
公开募捐{
试一试{
对于（int i=0；i<10；i++）
{  
已同步（锁定）
{                            
如果（！canWrite）
lock.wait（）；
系统输出println（x）；
canWrite=false；
lock.notify（）；
}
}                    
} 
捕获（中断异常e）{}
}
});        
线程t2=新线程（新可运行（）{
公开募捐{
试一试{
对于（int i=0；i<10；i++）
{                                                
已同步（锁定）
{                                                              
x++；
canWrite=true；
lock.notify（）；
lock.wait（）；
}
}                            
}catch（InterruptedException ex）{}
}
});
t1.start（）；
t2.start（）；
}
}

下面是一个有效的解决方案。关键在于添加一个额外的标志，该标志将指示写入线程是否具有写入权限。注意锁对象上的

final

，这是一种良好的做法

public class TestClass
{
    private static int x = 0;
    private static final Object lock = new Object();  
    private static boolean canWrite = false;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            public void run() {
                try {
                    for(int i = 0; i < 10; i++)
                    {  
                        synchronized(lock)
                        {                            
                            if(!canWrite)                            
                                lock.wait();
                            System.out.println(x);
                            canWrite = false;
                            lock.notify();
                        }
                    }                    
                } 
                catch (InterruptedException e) {}
            }
        });        

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    for(int i = 0; i < 10; i++)
                    {                                                
                        synchronized(lock)
                        {                                                              
                            x++;
                            canWrite = true;
                            lock.notify();
                            lock.wait();
                        }
                    }                            
                } catch (InterruptedException ex) {}                                                                        
            }
        });
        t1.start();        
        t2.start();
    }
}

公共类TestClass
{
私有静态int x=0；
私有静态最终对象锁=新对象（）；
私有静态布尔值canWrite=false；
公共静态void main（字符串[]args）{
线程t1=新线程（新的可运行线程（）{
公开募捐{
试一试{
对于（int i=0；i<10；i++）
{  
已同步（锁定）
{                            
如果（！canWrite）
lock.wait（）；
系统输出println（x）；
canWrite=false；
lock.notify（）；
}
}                    
} 
捕获（中断异常e）{}
jstack <pid>

lock.wait();

lock.wait();