两个线程交替打印奇偶数

最新推荐文章于 2025-05-29 20:37:16 发布

原创最新推荐文章于 2025-05-29 20:37:16 发布 · 596 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#两个线程交替打印奇偶数

java 专栏收录该内容

37 篇文章

订阅专栏

本文通过实例演示了Java中线程同步的实现方法，重点介绍了如何避免因对象引用变化导致的非法监视器异常，并展示了使用AtomicInteger进行线程安全计数的技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在做这个代码之前，其实碰到了一些问题，不过说到底还是基础不行，总结出来就是 切不要以Integer等作为锁的对象，也就是
被锁住的引用 所指向的对象一定不能变，用integer极其容易引起所指向对象的改变 如 i = i+1;等等 切记 切记 。否则会报错哦，（非法对象监视器异常）

例如 ： 有个Integer i对象
 synchronized (i) {
  i =i+1;
 i.wait(); //注意这里 i所指向的对象改变， 线程并没有获取到 i重新指 向对象的锁，故会报错 ）
}



wait(),notity(),notityAll()的具体使用方法 参考本篇文章  https://yq.aliyun.com/articles/1419 

package com.test;

import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadTest {
    public volatile static boolean flag1 = true;
    public volatile static AtomicInteger i = new AtomicInteger(0); //这里为了方便直接使用原子类，
                                                                    //其实可以创建一个对象
                                                                   //该对象有一个int属性即可 ；
    public static void main(String[] args) {
        Thread thread1 = new Thread1();
            Thread thread2 = new Thread2();
        thread1.start();
            thread2.start();
           

    }

    static class Thread1 extends Thread {

        @Override
        public void run() {
            while (i.get() < 10) {
                synchronized (i) {
                    try {
                        while (i.get()
                                % 2 == 0) {
                            System.out.println(Thread.currentThread() + ":" + i);
                            i.incrementAndGet();
                         //   System.out.println("2222");

                            i.notify();  //唤醒对象等待队列中的一个等待的线程


                        }
                        while (i.get() % 2 != 0) {
                            i.wait();  //奇数 ， wait暂时释放锁 ，成为阻塞状态
                        }



                    } catch (InterruptedException e) { //这里抓捕异常 一般不会进入这里
                        
                        e.printStackTrace();
                    }
                }
            }
            flag1 = false;

        }

        @Override
        public String toString() {
            return "Thread-1";
        }
    }

    static class Thread2 extends Thread {
        @Override
        public void run() {
            while (i.get() < 10){
                synchronized (i) {
                    try {
                        while (i.get() % 2 != 0) {
                           // System.out.println("第二个");
                            System.out.println(Thread.currentThread() + ":" + i);
                            i.incrementAndGet();
                            i.notify(); //唤醒对象等待队列中的一个等待的线程


                        }

                        if(i.get()%2==0){
                            i.wait(); //偶数 ， wait暂时释放锁 ，成为阻塞状态
                        }

                    } catch (InterruptedException e1) {
                       // System.out.println("第二个线程堵死");
                        e1.printStackTrace();
                    }


                }

        }
    }

    @Override
    public String toString() {
        return "Thread-2";
    }
}


}

最后还有一点值得注意的是这里会造成一个线程一直处于阻塞状态，造成原因是，当一个线程满足条件后退出，造成阻塞的线程会一直没有人唤醒。