Java同步方法的使用

我试图掌握Java中同步方法的概念，但遇到了令人困惑的行为，至少对我来说是这样； 在守则中：

public class parallelUpdate
{
    public static void main(String[] args)
    {
        Ob ob = new Ob();
        new Thread(ob).start();
        new Thread(ob).start();
    }
}

class Ob implements Runnable
{
    static int cnt = 0;

    private synchronized void inc()
    {
        cnt++;
    }

    @Override
    public void run()
    {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread());
            inc();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

我希望inc（）方法使用synchronized会产生顺序递增，如：

Thread[Thread-0,5，main]
螺纹[螺纹-0,5，主螺纹]
螺纹[螺纹-0,5，主螺纹]
螺纹[螺纹-0,5，主螺纹]
螺纹[螺纹-0,5，主螺纹]
螺纹[螺纹-1,5，主螺纹]
螺纹[螺纹-1,5，主螺纹]
螺纹[螺纹-1,5，主螺纹]
螺纹[螺纹-1,5，主螺纹]
螺纹[螺纹-1,5，主螺纹]

---

我的代码出了什么问题？

之所以会出现这种情况，是因为线程调度程序决定运行哪个线程，并且没有选择线程的特定顺序。您可以在线程上设置优先级，但还是要由调度程序选择优先级。您可以要求调度程序运行特定线程，但不能强制它。 同步一个方法可以保证该方法一次只由一个线程运行。 我还建议检查ThreadExecutersAPI，它提供了创建、维护和销毁线程的更干净的方法。

---

这里有一个关于java中线程的有用链接：

之所以会发生这种情况，是因为线程调度程序决定运行哪个线程，并且没有选择线程的特定顺序。您可以在线程上设置优先级，但还是要由调度程序选择优先级。您可以要求调度程序运行特定线程，但不能强制它。 同步一个方法可以保证该方法一次只由一个线程运行。 我还建议检查ThreadExecutersAPI，它提供了创建、维护和销毁线程的更干净的方法。

---

以下是有关java线程的有用链接：

请查找正确的代码：-

 public class parallelUpdate {
        public static void main(String[] args) {
            Ob ob = new Ob();
            new Thread(ob).start();
            new Thread(ob).start();

        }
    }


    class Ob implements Runnable {
        static int cnt = 0;
        private synchronized void inc() {
              for (int i = 0; i < 5; i++) {
                  System.out.println(Thread.currentThread());
                  cnt++;
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              } 
        }
        @Override
        public void run() {
          inc();
        }
    }

公共类并行更新{
公共静态void main（字符串[]args）{
Ob=新Ob（）；
新线程（ob.start（）；
新线程（ob.start（）；
}
}
类Ob实现可运行{
静态int cnt=0；
私人有限公司{
对于（int i=0；i<5；i++）{
System.out.println（Thread.currentThread（））；
cnt++；
试一试{
睡眠（100）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
} 
}
@凌驾
公开募捐{
公司（）；
}
}

根据您的代码进行解释：-

---

您正在制作inc（）方法作为一个已同步的方法，但它们对于

**for loop**

不同步，因此您的两个踏板进入并执行

inc（）同步操作。
请查找正确的代码：-

 public class parallelUpdate {
        public static void main(String[] args) {
            Ob ob = new Ob();
            new Thread(ob).start();
            new Thread(ob).start();

        }
    }


    class Ob implements Runnable {
        static int cnt = 0;
        private synchronized void inc() {
              for (int i = 0; i < 5; i++) {
                  System.out.println(Thread.currentThread());
                  cnt++;
                  try {
                      Thread.sleep(100);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              } 
        }
        @Override
        public void run() {
          inc();
        }
    }

公共类并行更新{
公共静态void main（字符串[]args）{
Ob=新Ob（）；
新线程（ob.start（）；
新线程（ob.start（）；
}
}
类Ob实现可运行{
静态int cnt=0；
私人有限公司{
对于（int i=0；i<5；i++）{
System.out.println（Thread.currentThread（））；
cnt++；
试一试{
睡眠（100）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
} 
}
@凌驾
公开募捐{
公司（）；
}
}

根据您的代码进行解释：-

您正在制作inc（）方法作为一个已同步的方法，但它们对于
**for loop**
不同步，因此您的两个踏板进入并执行
inc（）同步操作。
如果线程2在线程1之后启动，则更好的解决方案是使用联接方法，这意味着程序将希望在线程1完成之前启动线程2


转到java文档以阐明同步化方法的工作原理


首先，同一对象上的两个同步方法调用不可能交错。当一个线程为一个对象执行同步方法时，调用同一对象块的同步方法的所有其他线程（暂停执行），直到第一个线程对该对象执行完毕
其次，当同步方法退出时，它会自动与同一对象的同步方法的任何后续调用建立“发生在之前”关系。这保证了对象状态的更改对所有线程都可见
如果线程2在线程1之后启动，那么更好的解决方案是使用联接方法，这意味着程序将希望在线程1完成之前启动线程2


转到java文档以阐明同步化方法的工作原理


首先，同一对象上的两个同步方法调用不可能交错。当一个线程为一个对象执行同步方法时，调用同一对象块的同步方法的所有其他线程（暂停执行），直到第一个线程对该对象执行完毕
其次，当同步方法退出时，它会自动与同一对象的同步方法的任何后续调用建立“发生在之前”关系。这保证了对象状态的更改对所有线程都可见
尝试使用
run（）
方法
synchronized
而不是
inc（）
方法。使用
原子整数
类方法处理线程“我希望inc（）方法使用synchronized会产生顺序递增”为什么？您只同步了
inc
方法。这意味着没有两个线程可以并行执行它，但这并不意味着会有特定的执行顺序。@Konstantin请找到我的answer@Konstantin请投票（谢谢）尝试运行
run（）
me