Java 如何在静态同步块内进行线程间通信

我有一个关于静态同步方法和类级锁定的问题。 有人能帮我解释一下这个例子吗：

class Test
{
    synchronized static void printTest(int n)
    {
        for (int i = 1; i <= 10; i++) {
            System.out.println(n * i);
            try {
                Thread.sleep(400);
            } catch (Exception ignored) {}
        }
    } 
}  

class MyThread1 extends Thread
{
    public void run()
    {
        Test.printTest(1);
    }
}

class MyThread2 extends Thread
{
    public void run()
    {
        Test.printTest(10);
    }
}

public class TestSynchronization
{
    public static void main(String[] args)
    {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();
    }
}

类测试
{
同步静态无效打印测试（int n）
{
对于（inti=1；i您的评论：

有一个线程（t2）正在等待另一个线程（t1）持有的类级锁。因此，t1线程有可能在t1退出静态同步方法之前通知线程t2

是的，类是对象，只需调用
notify（）

类测试
{
同步静态无效打印测试（int n）
{
对于（inti=1；i您的评论：

有一个线程（t2）正在等待另一个线程（t1）持有的类级锁。因此，t1线程有可能在t1退出静态同步方法之前通知线程t2

是的，类是对象，只需调用
notify（）

类测试
{
同步静态无效打印测试（int n）
{
for（int i=1；i
interrupt（）
可根据您的要求在此处使用

如果您的需求在将来得到更改，并且在第二个线程之后需要执行第一个线程，则删除
If（thread.interrupted（））
inside
printTest

 class Test {
    synchronized static void printTest(int n) {
        for (int i = 1; i <= 10; i++) {
            if(Thread.interrupted())
                break;
            System.out.println(n * i);
            try {
                Thread.sleep(400);
            } catch (Exception e) {
            }
        }
    }
 }

 class MyThread1 extends Thread {
    public void run() {
        Test.printTest(1);
    }
 }

 class MyThread2 extends Thread {
    public void run() {
        Test.printTest(10);
    }
 }

 public class TestSynchronization {
    public static void main(String t[]) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();

        t1.interrupt();
        t1.join();
    }

 }

类测试{
同步静态无效打印测试（int n）{
for（int i=1；i
interrupt（）
可根据您的要求在此处使用

如果您的需求在将来得到更改，并且在第二个线程之后需要执行第一个线程，则删除
If（thread.interrupted（））
inside
printTest

 class Test {
    synchronized static void printTest(int n) {
        for (int i = 1; i <= 10; i++) {
            if(Thread.interrupted())
                break;
            System.out.println(n * i);
            try {
                Thread.sleep(400);
            } catch (Exception e) {
            }
        }
    }
 }

 class MyThread1 extends Thread {
    public void run() {
        Test.printTest(1);
    }
 }

 class MyThread2 extends Thread {
    public void run() {
        Test.printTest(10);
    }
 }

 public class TestSynchronization {
    public static void main(String t[]) throws InterruptedException {
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
        t1.start();
        t2.start();

        t1.interrupt();
        t1.join();
    }

 }

类测试{
同步静态无效打印测试（int n）{
对于（int i=1；i
由于我们处理类级锁，我相信我们不能使用对象级
wait（）
和
notify（）

我尽量避免说“类级别”或“对象级别”。无论何时使用
synchronized
都是在某个对象上进行同步。请记住：
Test。类
是一个对象：它包含描述
Test
类的所有运行时信息

当你说“类级锁定”时，你真正要说的是在全局单例对象（类对象）上同步，而不是“实例级锁定”，在“实例级锁定”中，类的许多不同实例可以独立地
同步

我想让它停止执行并将控制转移到线程t2

考虑线程时，这不是一种非常有用的方式。您通常不希望程序中的线程等待轮到它处理某项任务：您希望它等待自己的任务。线程之间总是需要相互协调和通信，但您越是能够让每个线程自行完成任务总之，你会更好地利用它们

不要考虑将控制权从一个线程转移到另一个线程，而是希望每个线程始终控制自己的事情

我们如何通知正在等待[…]锁的第二个线程

没有任何东西可以让线程免于等待进入
同步的
块。这是
同步的
的限制之一，这也是为什么任何线程在
同步的
块中停留的时间比更新几个字段的时间长的原因之一

我想让它停止执行死刑

引起循环线程注意的最简单方法是让线程每次在循环中检查
volatile boolean
变量的值

volatile boolean timeToStop = false;

MyType myMethod(...) {
    while (! timeToStop) {
        ...
    }
}

然后，任何其他线程都可以设置
timeToStop=true；
，以引起第一个线程的注意

由于我们处理类级锁，我相信我们不能使用对象级
wait（）
和
notify（）

我尽量避免说“类级别”或“对象级别”。无论何时使用
synchronized
都是在某个对象上进行同步。请记住：
Test。类
是一个对象：它包含描述
Test
类的所有运行时信息

当你说“类级锁定”时，你真正要说的是在全局单例对象（类对象）上同步，而不是“实例级锁定”，在“实例级锁定”中，类的许多不同实例可以独立地
同步

我想让它停止执行并将控制转移到线程t2

考虑线程时，这不是一种非常有用的方式。您通常不希望程序中的线程等待轮到它处理某项任务：您希望它等待自己的任务。线程之间总是需要相互协调和通信，但您越是能够让每个线程自行完成任务总之，你会更好地利用它们

不要考虑将控制权从一个线程转移到另一个线程，而是希望每个线程始终控制自己的事情

我们如何通知正在等待[…]锁的第二个线程

没有任何东西可以让线程免于等待进入
同步的
块。这是
同步的
的限制之一，这也是为什么任何线程在
同步的
块中停留的时间比更新几个字段的时间长的原因之一

我想让它停止执行死刑

引起循环线程注意的最简单方法是让线程每次在循环中检查
volatile boolean
变量的值

volatile boolean timeToStop = false;

MyType myMethod(...) {
    while (! timeToStop) {
        ...
    }
}

然后，任何其他线程都可以设置
timeToStop=true；
，以引起第一个线程的注意