Java 使用同步方法获取对象锁

下面的代码不提供同步输出

public class MultiThr implements Runnable{

public static void main(String[] args) {

    for(int i = 0;i < 5;i++){
        new Thread(new MultiThr()).start();
    }
}

@Override
public void run() {

    increment();
}

public synchronized void increment(){
    for(int i=0;i<10;i++){
        System.out.println(i);
        try {
            Thread.sleep(400);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
}

公共类MultiThr实现可运行{
公共静态void main（字符串[]args）{
对于（int i=0；i<5；i++）{
新线程（新MultiThr（））.start（）；
}
}
@凌驾
公开募捐{
增量（）；
}
公共同步的无效增量（）{
对于（int i=0；i，使用synchronized关键字会导致该方法在调用该方法的对象上获得锁定。由于您有5个
MultiThr
对象，因此有5个不同的对象被锁定

有许多选项可以解决此问题，例如，您可以创建一个对象，以便在所有
MultiThr
对象之间共享：

public class MultiThr implements Runnable{
    private static final Object lock = new Object();

    public static void main(String[] args) {
        for(int i = 0;i < 5;i++){
            new Thread(new MultiThr()).start();
        }
    }

    @Override
    public void run() {
        increment();
    }

    public void increment(){
        synchronized (lock) {
            for(int i=0;i<10;i++){
                System.out.println(i);
                try {
                    Thread.sleep(400);
                } catch (InterruptedException e) {}
            }
        }
    }
}

公共类MultiThr实现可运行{
私有静态最终对象锁=新对象（）；
公共静态void main（字符串[]args）{
对于（int i=0；i<5；i++）{
新线程（新MultiThr（））.start（）；
}
}
@凌驾
公开募捐{
增量（）；
}
公共空间增量（）{
已同步（锁定）{
对于（int i=0；i您的increment（）方法是同步的。您的问题是它是Runnable的一部分。更重要的是，您的计数器变量i是一个局部变量，因此即使没有synchronized关键字，每个线程也将有自己的i副本。
我建议您创建一个类myCenter，如：

class MyCounter {   

    private int i;

    public MyCounter () {
        i = 0;
    }

    public int getCounter() {
        return i;
    }

    public void increment() {
        i++;
    }
}

然后将其作为参数传递给MultiThr构造函数：

public class MultiThr implements Runnable{

    private MyCounter counter;

    public MultiThr(MyCounter counter)  {
        this.counter = counter;
    }

    @Override
    public void run() {  
        increment();
    }

    public synchronized void increment(){
        for(int i=0;i<10;i++){
            counter.increment();
            System.out.println(counter.getCounter());
            try {
                Thread.sleep(400);
            } catch (InterruptedException e) {
                // Do not do just e.printStackTrace()
                Thread.currentThread().interrupt()
            }
        }
    }

    public static void main(String[] args) {
        for(int i = 0;i < 5;i++){
           new Thread(new MultiThr()).start();
        }
    }
}

公共类MultiThr实现可运行{
私用MyCounter计数器；
公共多小时（MyCounter计数器）{
this.counter=计数器；
}
@凌驾
public void run（）{
增量（）；
}
公共同步的无效增量（）{
对于（inti=0；iWhy被否决？