Java 简单线程同步问题

在下面的代码中，如果我同步

bar

方法与否，输出不会有什么不同-我做错了什么？我相信同步“吧”会使“THREONE”打印10次，然后只打印“Thread2”即可开始，但情况并非如此。我得到的输出如下：

---

我是测试线程：线程一 我是测试线程：线程一 我是测试线程：线程一 我是测试线程：线程一 我现在是主要的 我是测试线程：线程一 我是测试线程：线程二 我是测试线程：线程二 我是测试线程：线程一 我是测试线程：线程二 我是测试线程：线程一 我是测试线程：线程二 我是测试线程：线程一 我是测试线程：线程二 我是测试线程：线程一 我是测试线程：线程二 我是测试线程：线程一 我是测试线程：线程二 我是测试线程：线程二 我是测试线程：线程二 我是测试线程：线程二 我现在是主要的 等等。这是我的密码：

package com.rahul;

class ThreadTest implements Runnable{
    @Override
    public void run() {
        bar();
    }
    public synchronized void bar() {
        for(int i=0;i<10;i++){
            System.out.println("I am Test thread:"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }
}

public class Test{
    public static void main(String[] args) {
        Thread t1 = new Thread(new ThreadTest(),"Thread OneOneOneOne");
        Thread t2 = new Thread(new ThreadTest(),"Thread Two");
        t1.start();
        try{
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        t2.start();
        while(true){
            System.out.println("I am in main now");
            try {
                t2.join();
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

package com.rahul；
类ThreadTest实现可运行{
@凌驾
公开募捐{
bar（）；
}
公共同步无效条（）{
对于（int i=0；i您有两个
ThreadTest
实例。它们彼此无关；您没有调用相同的
bar（）

如果您改为这样做：

ThreadTest tt = new ThreadTest();
Thread t1 = new Thread(tt,"Thread OneOneOneOne");
Thread t2 = new Thread(tt,"Thread Two");

然后两个线程共享
ThreadTest
的一个实例，只有一个线程能够调用
bar（）
一次在单个实例上执行。
声明要同步的方法将不会产生预期效果。每个线程都在其自己的
ThreadTest
实例上同步，因此调用不会交互。您需要在共享对象上同步一个线程以阻止另一个线程。例如：

class ThreadTest implements Runnable{
    private static Object LOCK_OBJECT = new Object();
    @Override
    public void run() {
        bar();
    }
    public void bar() {
        synchronized (LOCK_OBJECT) {
            for(int i=0;i<10;i++){
                System.out.println("I am Test thread:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

class ThreadTest实现可运行{
私有静态对象锁_Object=新对象（）；
@凌驾
公开募捐{
bar（）；
}
公共空白栏（）{
已同步（锁定对象）{
对于（inti=0；i，您正在同步的方法只被一个线程访问，因为它们是实例方法，所以每个线程都在调用自己的bar方法

也许你想将bar方法声明为
static
该死，我错过了。非常感谢Brian！
class ThreadTest implements Runnable{
    private static Object LOCK_OBJECT = new Object();
    @Override
    public void run() {
        bar();
    }
    public void bar() {
        synchronized (LOCK_OBJECT) {
            for(int i=0;i<10;i++){
                System.out.println("I am Test thread:"+Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}