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

Question

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

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();
    }
}

这是我的问题：

1. 奇数线程在 printOdd() 函数中执行，而偶数线程在 printEven() 函数中执行。我对两个线程都使用了一个内在锁；我不明白这两个线程如何同时存在于它们各自的同步块中，因为使用相同的锁。

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

3. 我想我仍然需要努力理解多线程概念，因为我正在努力理解自己的代码:p 谁能解释是否有更好的方法来仅使用我的多线程概念来做到这一点用过吗？

Answer 1

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

• 尽管您删除了通知/等待语句，但您仍然获得相同的输出，这可能是巧合。您是否尝试过使用相对较大的 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() 代替 notify

• 最小化线程间共享的状态。在这种情况下，您共享isOdd 和c。请注意，前者可以通过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 设置为适当值的方法，从而进一步简化线程类中的代码 - 并减少同步/通知与数据处理的交错，这使代码更具可读性且不易出错。