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（）函数中执行，而偶数线程在printEven（）函数中执行。我正在为两个线程使用一个内部锁;我不明白两个线程如何同时存在于它们各自的同步块中，因为使用相同的锁。
我从代码中删除了线程通信语句（通知，等待），但仍然获得了我想要的输出。我现在想知道我的代码是否真的需要线程通信声明。
我想我仍然需要努力理解多线程概念，因为我正在努力理解我自己的代码：p任何人都可以解释是否有更好的方法来使用我只使用多线程概念用过？

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（）代替通知
最小化线程之间共享的状态。在这种情况下，您共享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设置为适当的值因此，进一步简化了线程类中的代码 - 并使同步/通知与数据处理的交错更少，这使得代码更易读，更不容易出错。

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

1 个答案: