两个线程，两个同步块和一个内在锁

Question

我写了一个启动两个线程的代码片段；一个线程打印所有奇数，而另一个线程打印所有偶数。我使用了内在锁和线程通信命令的组合来实现两个线程的正确交叉。这是我的代码，

public class threadEvenOdd implements Runnable
{
    static Boolean isOdd=true;
    int count = 10;
    Boolean value;
    static int c=1;
    static Object lock = new Object();

    threadEvenOdd(Boolean temp)
    {
        value = temp;
    }
    public void run()
    {
        if(value)
        {
            printOdd(count);
        }
        if(!value)
        {
            printEven(count);
        }
    }
    void printOdd(int count)
    {
        try
        {
            for(int i=0;i<count/2;i++)
            {
                //System.out.println("odd enters lock");
                synchronized(lock)
                {
                    if(!isOdd)
                    {
                        //System.out.println("odd in barrier");
                        lock.wait();
                    }
                    System.out.println(c);
                    c++;
                    isOdd = false;
                    //System.out.println("odd notifies");
                    lock.notify();
                }
            }
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
    }
    void printEven(int count)
    {
        try
        {
            for(int i=0;i<count/2;i++)
            {
                //System.out.println("even enters lock");
                synchronized(lock)
                {
                    if(isOdd)
                    {
                        //System.out.println("even in barrier");
                        lock.wait();
                    }
                    System.out.println(c);
                    c++;
                    isOdd = true;
                    //System.out.println("even notifies");
                    lock.notify();
                }
            }
        }
        catch(Exception e)
        {
            System.out.println(e);
        }
    }
    public static void main (String args[])
    {
        threadEvenOdd th1 = new threadEvenOdd(true);
        threadEvenOdd th2 = new threadEvenOdd(false);
        Thread t1 = new Thread(th1);
        t1.setName("odd");
        Thread t2 = new Thread(th2);
        t2.setName("even");
        //System.out.println(t1.getName() + " starts");
        t1.start();
        //System.out.println(t2.getName() + " starts");
        t2.start();
    }
}

以下是我的问题：

>

奇数线程在printOdd（）函数中执行，而偶数线程在print偶数（）函数中执行。我对两个线程都使用一个内在锁；我不明白两个线程怎么能同时存在于各自的同步块中，因为使用了相同的锁。

我从代码中删除了线程通信语句（通知，等待），但仍然获得了所需的输出。我现在想知道我的代码是否真的需要线程通信语句。

我想我仍然需要努力理解多线程概念，因为我正在努力理解我自己的代码:p谁能解释一下是否有更好的方法来做到这一点，只使用我使用的html" target="_blank">多线程概念？

Answer 1

>

每个线程都有自己的代码执行路径。即使两个线程运行完全相同的代码，它们仍然有两个不同的执行点，通过代码执行代码。当线程到达同步语句时，它会等待锁可用 - 仅当由同一锁保护的同步块内没有其他线程时，它才会进入同步块。

尽管删除了notify/wait语句，但仍会得到相同的输出。您是否尝试使用相对较大的count字段值来执行此操作？

现在很难回答这个问题，因为你没有具体说明你期望这个程序产生什么输出。“1，3，5，7，9，2，4，6，8”是有效输出吗？是“1，3，2，4，6，5，7，9，8”？还是说“1，2，3，4，5，6，7，8，9”是唯一有效的输出？也就是说，这里有几个要点:

使用 notifyAll（） 代替通知

最小化线程间共享的状态。在这种情况下，您共享< code>isOdd和< code>c。请注意，前者可以通过< code>c % 2 == 1从后者计算得出。因此，您可以让线程计算异常，而不是将其作为共享数据来维护。

不是通过静态字段共享，而是创建一个对象（带有实例字段）并将此对象传递给每个线程的构造函数。然后您可以将对象本身用作锁。

下面是它的外观：

class SharedData {
    int c;
    boolean isOdd;
} 

class ThreadEvenOdd {
    SharedData sharedData;

    public ThreadEvenOdd(SharedData sd) { this.sharedData = sd }

    // ...

    void printOdd(int count) {
        try {
            for(int i=0;i<count/2;i++) {
                synchronized(sharedData) {
                    if(!sharedData.isOdd) { ... }
                    System.out.println(sharedData.c);
                    sharedData.c++;
                    sharedData.isOdd = false;
                    lock.notify();
                }
            }
        }
        catch(Exception e) {
            System.out.println(e);
        }
    }
}   

这样做的好处是，您可以开始在 sharedData 上定义真正的方法（例如：一种增加 c 并根据 c 的值将 isOdd 设置为适当值的方法，从而进一步简化了线程类中的代码 - 并使同步/通知与数据处理的交错更少， 这使得代码更具可读性，不易出错。