同步无助于实现互斥

Question

C类：

class C extends Thread
{
    public static int cr;

    C(int n) 
    {
        cr = n;
    }

    public void run()
    {
        go();
    }

    synchronized void go()
    {
        for (int i = 0; i < 10000; i++)
        {
            cr++;
        }
    }
}

开课

class Launch
{
    public static void main(String args[]) throws InterruptedException
    {
        C[] c = new C[10];

        for (int i = 0; i < 10; i++)
        {
            c[i] = new C(0);
        }

        for (int i = 0; i < 10; i++)
        {
            c[i].start();
        }

        System.out.println(C.spaces);
    }
}

它给我的不是 100,000，而是低于 100k 的数字。为什么？我做了go()同步的方法，所以它一次只能被一个线程使用..？我错过了什么？

Answer 1

synchronized void go(){...} 表示它在当前实例（this）上同步。由于此方法属于您的自定义 Thread 类并且您正在创建 10 个线程，因此存在 10 个不同的 this 引用。

这是首选不扩展 Thread 类，而是实现Runnable 接口并将此接口的实例传递给任意数量的线程的原因之一。

另一个问题是您在不等待线程完成的情况下打印已编辑的值。

您需要创建一个实例，该实例将保存您想要更改的值并仅从 一个实例 调用同步方法，因为默认情况下提到 synchronized void method 是在this（调用此方法的当前对象）上同步。

class MyTask implements Runnable {

    public volatile int counter;

    MyTask(int n) {
        counter = n;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName()+" entered run");
        go();
        System.out.println(Thread.currentThread().getName()+" finished run");
    }

    synchronized void go() {

        System.out.println(Thread.currentThread().getName()+" entered go");
        for (int i = 0; i < 10000; i++) {
            counter++;
        }
        System.out.println(Thread.currentThread().getName()+" left from go");
    }
}

class Luncher {
    public static void main(String args[]) throws InterruptedException {

        //lets create task we want to execute in parallel
        MyTask task = new MyTask(0);

        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++)//create thread instances
            threads[i] = new Thread(task);

        for (int i = 0; i < 10; i++)//start threads
            threads[i].start();

        for (int i = 0; i < 10; i++)
            threads[i].join();//hold main thread to wait till all threads will finish
        System.out.println(task.counter);
    }
}

Answer 2

与

 c[i] = new C(0);

你每次都在创建新的 c 实例

与

 synchronized void go()
{
    for (int i = 0; i < 10000; i++)
    {
        cr++;
    }
}

你总是会得到小于 10000 的数字，我不知道你为什么期望 100,000

i

回答你的最后一个问题

I made method go() synchronized, so it should be used by only one thread at a time..?

如果一次只有一个线程，则不需要同步（多线程概念）。

Answer 3

它给我的不是 100,000，而是低于 100k 的数字。为什么？

一切正常，但main 线程不等待其他线程完成计算，因此main 线程中的输出是随机的。

使用Thread#join()，这样主线程在执行主线程的最后一行之前等待所有其他线程死亡。

for (int i = 0; i < 10; i++) {
    c[i].start();
    c[i].join(); // Waits for this thread to die
}

System.out.println(C.cr); // output 100000

---

值得一读How do I pause main() until all other threads have died?