java - 两个线程、两个同步块(synchronized block)和一个内在锁

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

这是我的问题:

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

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

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

Answer 1

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

• 尽管您删除了通知/等待语句，但您仍然得到相同的输出，这可能是巧合。您是否尝试过使用相对较大的 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并将isOdd设置为基于适当值的方法c 的值，从而进一步简化了线程类中的代码 - 并减少了同步/通知与数据处理的交错，这使得代码更具可读性并且不易出错。