php计算200以内偶数的和并输出_java面试题:多线程交替输出偶数和奇数

一个面试题:实现两个线程A,B交替输出偶数和奇数

问题:创建两个线程A和B,让他们交替打印0到100的所有整数,其中A线程打印偶数,B线程打印奇数

这个问题配合java的多线程,很多种实现方式

在具体实现之前,首先介绍一下java并发编程中共享变量的可见性问题。

可见性问题:

在java内存模型(JMM,java Memory Model)中定义了程序中各种共享变量的访问规则。

这里的共享变量指的是可以在线程之间共享的变量,包括实例字段,静态字段和构成数组对象的元素。

不包括局部变量和方法参数(这些都是在虚拟机栈中,是线程私有的)

在java内存模型中,规定所有的变量都保存在主内存中(JVM内存中的一个空间)。

此外,对于每个线程,都拥有自己的工作内存,在工作内存中存储了该线程使用的共享变量的主内存副本(从主内存中拷贝过来的)。

每个线程只能在工作内存中对共享变量的副本进行操作(读,赋值),不能直接读写主内存中的数据。

各个线程之间也无法访问对方工作内存中的变量副本,所有的线程只能通过主内存来完成变量的值传递。

fe513c31761044a734a0c6290fa0d5b4.png

在java内存模型中,定义了8中原子操作来完成工作内存与主内存之间的拷贝与同步。

这里重点关注一下,两个线程同时读取与修改同一个共享变量的问题。

当我们创建了一个静态变量之后,它就会被保存在主内存中。如果有两个线程A,B要访问这个静态变量并对其进行修改,线程会读取(read操作)这个变量的值并放到(load操作)线程的工作内存中的变量,线程在执行完修改指令后,将修改后的值赋值给(assign操作)工作内存中的变量,然后执行store操作将工作内存中变量的值传送到主内存中,然后使用write操作将传递过来的值放入到主内存变量中。

read操作和load操作必须按顺序执行,store操作和write操作也必须按顺序执行。

但是这里存在一个问题,即变量的可见性,read/load和store/write虽然是按顺序执行,但却不是连续执行的,也就是说工作内存中的变量值在修改完并复制给工作内存中的变量后,并不是立即执行store/write操作的,这就导致主内存中的变量值无法实时的得到更新。这时候如果另一个线程要读取主内存中该变量的值,仍然是旧值,无法读取到新值。只有在回写完成,才能在主内存中读取到新的值。

这里我们用一个例子来展示变量的可见性问题,使用错误的方法来实现两个线程交替输出偶数和奇数

方案1:使用自旋检查(循环检查)来实现线程交替输出

/*定义两个线程A和B,让两个线程按顺序交替输出偶数和奇数(A输出偶数,B输出奇数)*/public class ThreadNum {  public static int flag = 0; //定义一个静态全局变量,作为标志位  public static void main(String[] args) {    Thread r1 = new Thread( //线程1用来输出偶数      ()->{        while(flag<=100){          while(flag%2==1&&flag<=100);      //循环判断,如果flag是偶数就跳出循环去flag          System.out.println(Thread.currentThread().getName()+"打印:"+flag);          flag++;//自增1,flag变成奇数        }      }    );    Thread r2 = new Thread(//线程B用来输出奇数      ()->{        while(flag<100){          while(flag%2==0&&flag<100);//循环判断,如果flag为奇数就跳出循环去打印flag          System.out.println(Thread.currentThread().getName()+"打印:"+flag);          flag++; //自增1,flag变成偶数        }      }    );    r1.setName("线程A");    r2.setName("线程B");    r1.start();    r2.start();  }}/*程序运行结果:线程A打印:0线程B打印:1线程A打印:2线程B打印:3线程A打印:4线程B打印:5在这里死循环,无法继续打印*/

这个程序在运行时可能会死循环,两个线程会在while(flag%2==0&&flag<=100);和while(flag%2==1&&flag<100);这里死循环。分析一下原因:

静态变量flag是一个普通变量,无法保证对所有的线程的可见性。

所以当线程B在打印出flag的值5之后,执行自增操作,将自己工作内存内的变量值更新为6,但是并没有立即更新到主内存中(应为工作内存中的值更新后并不会直接写入到主内存中),即便是更新到了主内存中,但是java内存模型没有规定主内存中变量值发生改变后会立即更新线程工作内存中对应的变量副本的值,此时线程A在执行循环,它读取的flag值始终是工作内存中的旧值5,导致无法跳出循环。

这样对于flag的值:

线程A工作内存中:flag=5,仍然为旧值,无法跳出循环while(flag%2==1&&flag<100);

线程B工作内存中:flag从5变成6,然后执行循环while(flag%2==0&&flag<=100);,同样无法跳出

主内存中:flag开始值为5,当从线程B中得到更新后的值,变成6.但是不会主动将更新后的值传递给线程B。

为了解决这个变量的可见性问题,java引入了volatile型变量,来保证共享变量的改变对所有线程的可见性。

当一个线程修改了这个变量的值,新的值对其他线程来说是立即可见的。当其他线程读取自己被volatile修饰的该变量时,会直接从主存中读取数据从而刷新自己工作内存中的数据,保证读取到最新的值。

修改后的实现方法:

方案2:使用volatile型变量和自旋检查来实现交替输出:

/*定义两个线程A和B,让两个线程按顺序交替输出偶数和奇数(A输出偶数,B输出奇数)*/public class ThreadNum {    public static volatile int flag = 0; //使用volatile 来保证flag对两个线程的可见性    private static final int N  = 200;    public static void main(String[] args) {        //AtomicInteger flag = new AtomicInteger(0);        Thread r1 = new Thread( //线程A用来输出偶数            ()->{                while(flag<=N){                    while(flag%2==1&&flag<=N);           //循环判断当前flag是否是偶数                    //lock.lock(); //先获取锁                    System.out.println(Thread.currentThread().getName()+"打印:"+flag);                    flag++;//自增1                    //lock.unlock();//释放锁                }            }        );        Thread r2 = new Thread(//线程B用来输出奇数            ()->{                while(flag

在上面的方案中,线程之间通过自旋检查来保证并发性,也就是当过某个线程发现当前自己无法进行输出时,他会循环检查对应的条件,知道条件满足,线程执行输出操作。

在这种方案中,线程没有被阻塞,时钟在占用CPU执行循环。

另一种实现方案是利用互斥锁来保证线程之间的并发性(有序执行),同一时刻,只有获取到锁的线程才能对变量进行操作(主要是修改)。而无法获得锁的线程会堵塞,知道锁被释放,他们才有机会获取锁。

同时,采用条件变量(Condition)的await()和signal()方法来实现实现两个线程的交替输出

对于获取到锁lock的线程,如果当前无法满足输出要求(比如flag不是奇数),该线程会被挂起(await()),同时将锁释放并等待。

而其他可以进行输出的线程,在操作完之后,会调用signal()方法或者signalAll()方法,来唤醒被挂起的线程,同时自己释放锁,使得被唤醒的线程可以再次尝试获取锁,并错上次被挂起的位置继续执行。

采用volatile 型变量和ReentrantLock锁以及Condition条件变量的实现方案

import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.ReentrantLock;/*定义两个线程A和B,让两个线程按顺序交替输出偶数和奇数(A输出偶数,B输出奇数)*/public class ThreadPrint2 {    public static volatile int flag = 0; //volatile修饰变量保证对线程的可见性    private static final int N  = 50;    public static void main(String[] args) {        ReentrantLock lock = new ReentrantLock();//声明一个锁对象,        Condition c = lock.newCondition();//创建这个锁对应的一个条件变量        Thread r1 = new Thread( //线程A用来输出偶数            ()->{                while(flag<=N){                    try{                        lock.lock();//首先获取锁                        if(flag%2==1){//如果当前值为奇数,就将线程阻塞挂起                            c.await();//将当前线程挂起                        }                        System.out.println(Thread.currentThread().getName()+"打印:"+flag);                        flag++;//自增1                        c.signal(); //唤醒其他因为这个条件而被被挂起的线程                    }catch(InterruptedException e){                            e.printStackTrace();                    }finally{                         //这里必须在finally代码块中来释放锁,防止应其他异常导致线程中断,但是锁    //却没有释放,导致出现死锁                        lock.unlock();                    }                }            }        );        Thread r2 = new Thread(//线程B用来输出奇数            ()->{                while(flag
### 回答1: 可以使用Java来创建两个线程分别交替输出奇数偶数,不输出星号一直输出,可以这样做:1. 创建一个类,它实现Runnable接口,该接口定义了一个run()方法,该方法将被线程调用;2. 为run()方法编写代码,用来交替输出奇数偶数,不输出星号一直输出;3. 创建两个线程,并将创建的类的实例作为参数传递给它们;4. 启动线程,线程将调用run()方法,并交替输出奇数偶数,不输出星号一直输出。 ### 回答2: 下面是用Java编写的实现代码,其中使用了两个线程分别交替输出奇数偶数,并且不输出星号。 ```java public class OddEvenPrinter { private int limit; private volatile boolean isOddPrinting = true; public OddEvenPrinter(int limit) { this.limit = limit; } public static void main(String[] args) { int limit = 100; OddEvenPrinter printer = new OddEvenPrinter(limit); Thread oddThread = new Thread(() -> { for (int i = 1; i <= limit; i += 2) { synchronized (printer) { while (!printer.isOddPrinting) { try { printer.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(i); printer.isOddPrinting = false; printer.notifyAll(); } } }); Thread evenThread = new Thread(() -> { for (int i = 2; i <= limit; i += 2) { synchronized (printer) { while (printer.isOddPrinting) { try { printer.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println(i); printer.isOddPrinting = true; printer.notifyAll(); } } }); oddThread.start(); evenThread.start(); } } ``` 这个程序创建了两个线程,oddThread用于输出奇数,evenThread用于输出偶数。通过一个共享的标志位isOddPrinting来控制两个线程的交替输出。 其中使用了synchronized关键字来保证线程同步。每个线程在输出一个数字后,都会调用notifyAll()方法来唤醒等待的线程,然后自己等待,直到被唤醒再继续执行。同时,使用while循环来防止虚假唤醒(spurious wake-ups)的情况发生。 这样,oddThread和evenThread就可以交替输出奇数偶数,直到达到限制的数字个数。 ### 回答3: 以下是一个用Java编写的程序,利用两个线程交替输出奇数偶数: ```java public class OddEvenPrinter { private static volatile int counter = 1; private static final Object lock = new Object(); public static void main(String[] args) { Thread oddThread = new Thread(OddEvenPrinter::printOdd); Thread evenThread = new Thread(OddEvenPrinter::printEven); oddThread.start(); evenThread.start(); } public static void printOdd() { while (true) { synchronized (lock) { if (counter % 2 != 0) { System.out.println(counter); counter++; lock.notify(); } else { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } public static void printEven() { while (true) { synchronized (lock) { if (counter % 2 == 0) { System.out.println(counter); counter++; lock.notify(); } else { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } } ``` 这个程序中,我们使用一个共享的`counter`变量来记录当前应该输出的数字,初始为1。使用`synchronized`关键字保证了两个线程的互斥访问,而`wait()`和`notify()`方法用于实现线程的等待和唤醒。每个线程在输出一个数字后,会调用`wait()`方法等待另一个线程的通知。当另一个线程输出完毕后,会调用`notify()`方法唤醒等待的线程,使其继续执行。 注意:为了控制输出长度,这里的程序并没有加入退出条件,需要手动终止程序的运行。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值