L'impression de pair et de l'Impair à l'aide de deux Threads en Java

Trouvé la solution. Quelqu'un cherche une solution à ce problème peut se référer 🙂

public class PrintEvenOddTester {
public static void main(String... args) {
Printer print = new Printer();
Thread t1 = new Thread(new TaskEvenOdd(print, 10, false));
Thread t2 = new Thread(new TaskEvenOdd(print, 10, true));
t1.start();
t2.start();
}
}
class TaskEvenOdd implements Runnable {
private int max;
private Printer print;
private boolean isEvenNumber;
TaskEvenOdd(Printer print, int max, boolean isEvenNumber) {
this.print = print;
this.max = max;
this.isEvenNumber = isEvenNumber;
}
@Override
public void run() {
//System.out.println("Run method");
int number = isEvenNumber == true ? 2 : 1;
while (number <= max) {
if (isEvenNumber) {
//System.out.println("Even :"+ Thread.currentThread().getName());
print.printEven(number);
//number+=2;
} else {
//System.out.println("Odd :"+ Thread.currentThread().getName());
print.printOdd(number);
//number+=2;
}
number += 2;
}
}
}
class Printer {
boolean isOdd = false;
synchronized void printEven(int number) {
while (isOdd == false) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Even:" + number);
isOdd = false;
notifyAll();
}
synchronized void printOdd(int number) {
while (isOdd == true) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Odd:" + number);
isOdd = true;
notifyAll();
}
}

Cela donne de sortie comme:

Odd:1
Even:2
Odd:3
Even:4
Odd:5
Even:6
Odd:7
Even:8
Odd:9
Even:10

OriginalL'auteur Suvasis

Utilisez cette très simple de JAVA 8 Classe Runnable fonction

public class MultiThreadExample {
static AtomicBoolean isEven = new AtomicBoolean(false);
static AtomicInteger atomicNumber = new AtomicInteger(1);
static Object object = new Object();
public static void main(String[] args) {
Runnable print = () -> {
while (atomicNumber.get() < 10) {
synchronized (object) {
if ((atomicNumber.get() % 2 == 0) && "Even".equals(Thread.currentThread().getName())) {
System.out.println("Even" + ":" + atomicNumber.getAndIncrement());
} else if ((atomicNumber.get() % 2 != 0) && "Odd".equals(Thread.currentThread().getName())) {
System.out.println("Odd" + ":" + atomicNumber.getAndIncrement());
}
}
}
};
Thread t1 = new Thread(print);
t1.setName("Even");
t1.start();
Thread t2 = new Thread(print);
t2.setName("Odd");
t2.start();
}
}

OriginalL'auteur Raj Ved

La même chose peut être fait avec l'interface de Verrouillage:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class NumberPrinter implements Runnable {
private Lock lock;
private Condition condition;
private String type;
private static boolean oddTurn = true;
public NumberPrinter(String type, Lock lock, Condition condition) {
this.type = type;
this.lock = lock;
this.condition = condition;
}
public void run() {
int i = type.equals("odd") ? 1 : 2;
while (i <= 10) {
if (type.equals("odd"))
printOdd(i);
if (type.equals("even"))
printEven(i);
i = i + 2;
}
}
private void printOdd(int i) {
//synchronized (lock) {
lock.lock();
while (!oddTurn) {
try {
//lock.wait();
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(type + " " + i);
oddTurn = false;
//lock.notifyAll();
condition.signalAll();
lock.unlock();
}
//}
private void printEven(int i) {
//synchronized (lock) {
lock.lock();
while (oddTurn) {
try {
//lock.wait();
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(type + " " + i);
oddTurn = true;
//lock.notifyAll();
condition.signalAll();
lock.unlock();
}
//}
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
Thread odd = new Thread(new NumberPrinter("odd", lock, condition));
Thread even = new Thread(new NumberPrinter("even", lock, condition));
odd.start();
even.start();
}
}

OriginalL'auteur vijayinani

Ce code fonctionne également très bien.

class Thread1 implements Runnable {
private static boolean evenFlag = true;
public synchronized void run() {
if (evenFlag == true) {
printEven();
} else {
printOdd();
}
}
public void printEven() {
for (int i = 0; i <= 10; i += 2) {
System.out.println(i+""+Thread.currentThread());
}
evenFlag = false;
}
public  void printOdd() {
for (int i = 1; i <= 11; i += 2) {
System.out.println(i+""+Thread.currentThread());
}
evenFlag = true;
}
}
public class OddEvenDemo {
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread td1 = new Thread(t1);
Thread td2 = new Thread(t1);
td1.start();
td2.start();
}
}

OriginalL'auteur Shailendra

L'autre question a été fermé comme un doublon de celui-ci. Je pense que nous pouvons sans risque de se débarrasser de "pair ou impair" problème et utiliser le wait/notify construire comme suit:

public class WaitNotifyDemoEvenOddThreads {
/**
* A transfer object, only use with proper client side locking!
*/
static final class LastNumber {
int num;
final int limit;
LastNumber(int num, int limit) {
this.num = num;
this.limit = limit;
}
}
static final class NumberPrinter implements Runnable {
private final LastNumber last;
private final int init;
NumberPrinter(LastNumber last, int init) {
this.last = last;
this.init = init;
}
@Override
public void run() {
int i = init;
synchronized (last) {
while (i <= last.limit) {
while (last.num != i) {
try {
last.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " prints: " + i);
last.num = i + 1;
i += 2;
last.notify();
}
}
}
}
public static void main(String[] args) {
LastNumber last = new LastNumber(0, 10); //or 0, 1000
NumberPrinter odd = new NumberPrinter(last, 1);
NumberPrinter even = new NumberPrinter(last, 0);
new Thread(odd, "o").start();
new Thread(even, "e").start();
}
}

OriginalL'auteur Kedar Mhaswade

J'ai fait de cette manière, lors de l'impression à l'aide de deux fils nous est impossible de prédire la séquence thread qui

était exécutée en premier afin de surmonter cette situation, nous avons pour synchroniser la ressource partagée,dans

mon cas, la fonction d'impression de deux threads tentent d'accéder.

class Printoddeven{
public synchronized void print(String msg) {
try {
if(msg.equals("Even")) {
for(int i=0;i<=10;i+=2) {
System.out.println(msg+" "+i);
Thread.sleep(2000);
notify();
wait();
}
} else {
for(int i=1;i<=10;i+=2) {
System.out.println(msg+" "+i);
Thread.sleep(2000);
notify();
wait();
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class PrintOdd extends Thread{
Printoddeven oddeven;
public PrintOdd(Printoddeven oddeven){
this.oddeven=oddeven;
}
public void run(){
oddeven.print("ODD");
}
}
class PrintEven extends Thread{
Printoddeven oddeven;
public PrintEven(Printoddeven oddeven){
this.oddeven=oddeven;
}
public void run(){
oddeven.print("Even");
}
}
public class mainclass 
{
public static void main(String[] args) {
Printoddeven obj = new Printoddeven();//only one object  
PrintEven t1=new PrintEven(obj);  
PrintOdd t2=new PrintOdd(obj);  
t1.start();  
t2.start();  
}
}

OriginalL'auteur shivaitian

Voici le code de travail d'impression étrange même pas sinon à l'aide d'attendre et d'en informer le mécanisme. J'ai restreindre la limite de chiffres à imprimer de 1 à 50.

public class NotifyTest {
Object ob=new Object(); 
public static void main(String[] args) {
//TODO Auto-generated method stub
NotifyTest nt=new NotifyTest();
even e=new even(nt.ob);     
odd o=new odd(nt.ob);
Thread t1=new Thread(e);
Thread t2=new Thread(o);
t1.start();     
t2.start();
}
}    
class even implements Runnable
{
Object lock;        
int i=2;
public even(Object ob)
{
this.lock=ob;       
}
@Override
public void run() {
//TODO Auto-generated method stub      
while(i<=50)
{
synchronized (lock) {               
try {
lock.wait();
} catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("Even Thread Name-->>" + Thread.currentThread().getName() + "Value-->>" + i);
i=i+2;              
}           
}       
} 
class odd implements Runnable
{
Object lock;
int i=1;    
public odd(Object ob)
{
this.lock=ob;
}
@Override
public void run() {
//TODO Auto-generated method stub
while(i<=49)
{
synchronized (lock) {               
System.out.println("Odd Thread Name-->>" + Thread.currentThread().getName() + "Value-->>" + i);
i=i+2;              
lock.notify();
}
try {
Thread.sleep(1000);
} catch (Exception e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
}       
}

OriginalL'auteur ProblemSolver

Je pense que les solutions proposées sont inutilement ajouté des trucs et de ne pas utiliser les sémaphores à son plein potentiel. Voici ce que ma solution est.

package com.test.threads;
import java.util.concurrent.Semaphore;
public class EvenOddThreadTest {
public static int MAX = 100;
public static Integer number = new Integer(0);
//Unlocked state
public Semaphore semaphore = new Semaphore(1);
class PrinterThread extends Thread {
int start = 0;
String name;
PrinterThread(String name ,int start) {
this.start = start;
this.name = name;
}
@Override
public void run() {
try{
while(start < MAX){
//try to acquire the number of semaphore equal to your value
//and if you do not get it then wait for it.
semaphore.acquire(start);
System.out.println(name + " : " + start);
//prepare for the next iteration.
start+=2;
//release one less than what you need to print in the next iteration.
//This will release the other thread which is waiting to print the next number.
semaphore.release(start-1);
}
} catch(InterruptedException e){
}
}
}
public static void main(String args[]) {
EvenOddThreadTest test = new EvenOddThreadTest();
PrinterThread a = test.new PrinterThread("Even",1);
PrinterThread b = test.new PrinterThread("Odd", 2);
try {
a.start();
b.start();
} catch (Exception e) {
}
}
}

OriginalL'auteur udit

Solution de travail à l'aide de classe unique

package com.fursa.threads;
public class PrintNumbers extends Thread {
Object lock;
PrintNumbers(Object lock) {
this.lock = lock;
}
public static void main(String ar[]) {
Object obj = new Object();
//This constructor is required for the identification of wait/notify
//communication
PrintNumbers odd = new PrintNumbers(obj);
PrintNumbers even = new PrintNumbers(obj);
odd.setName("Odd");
even.setName("Even");
even.start();
odd.start();
}
@Override
public void run() {
for(int i=0;i<=100;i++) {
synchronized (lock) {
if (Thread.currentThread().getName().equals("Even")) {
if(i % 2 == 0 ){
System.out.println(Thread.currentThread().getName() + " - "+ i);
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}                   
else if (i % 2 != 0 ) {
lock.notify();
}
}
if (Thread.currentThread().getName().equals("Odd")) {
if(i % 2 == 1 ){
System.out.println(Thread.currentThread().getName() + " - "+ i);
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}                   
else if (i % 2 != 1 ) {
lock.notify();
}
}
}
}
}
}

OriginalL'auteur Nikhil Kumar K

Cela peut être obtenue à l'aide de Verrouillage et l'État :

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class EvenOddThreads {
public static void main(String[] args) throws InterruptedException {
Printer p = new Printer();
Thread oddThread = new Thread(new PrintThread(p,false),"Odd  :");
Thread evenThread = new Thread(new PrintThread(p,true),"Even :");
oddThread.start();
evenThread.start();
}
}
class PrintThread implements Runnable{
Printer p;
boolean isEven = false;
PrintThread(Printer p, boolean isEven){
this.p = p;
this.isEven = isEven;
}
@Override
public void run() {
int i = (isEven==true) ? 2 : 1;
while(i < 10 ){
if(isEven){
p.printEven(i);
}else{
p.printOdd(i);
}
i=i+2;
}
}
}
class Printer{
boolean isEven = true;
Lock lock = new ReentrantLock();
Condition condEven = lock.newCondition();
Condition condOdd = lock.newCondition();
public void printEven(int no){
lock.lock();
while(isEven==true){
try {
condEven.await();
} catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() +no);
isEven = true;
condOdd.signalAll();
lock.unlock();
}
public void printOdd(int no){
lock.lock();
while(isEven==false){
try {
condOdd.await();
} catch (InterruptedException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() +no);
isEven = false;
condEven.signalAll();
lock.unlock();
}
}

OriginalL'auteur Prakash Hari Sharma

public class Solution {

 static class NumberGenerator{
private static volatile boolean printEvenNumber = false;
public  void printEvenNumber(int i) {
synchronized (this) {
if(!printEvenNumber) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i);
printEvenNumber = !printEvenNumber;
notify();
}
}
public  void printOddNumber(int i ) {
synchronized (this) {
if(printEvenNumber) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i);
printEvenNumber = !printEvenNumber;
notify();
}
}
}
static  class OddNumberGenerator implements Runnable{
private NumberGenerator numberGenerator;
public OddNumberGenerator(NumberGenerator numberGenerator) {
this.numberGenerator = numberGenerator;
}
@Override
public void run() {
for(int i  = 1; i <100; i = i + 2) {
numberGenerator.printOddNumber(i);
}
}
}
static class EvenNumberGenerator implements Runnable {
private NumberGenerator numberGenerator;
public EvenNumberGenerator(NumberGenerator numberGenerator) {
this.numberGenerator = numberGenerator;
}
@Override
public void run() {
for (int i = 2; i <= 100; i =  i + 2) {
numberGenerator.printEvenNumber(i);
}
}
}
public static void main(String[] args) {
NumberGenerator ng = new NumberGenerator();
OddNumberGenerator oddNumberGenerator = new OddNumberGenerator(ng);
EvenNumberGenerator evenNumberGenerator = new EvenNumberGenerator(ng);
new Thread(oddNumberGenerator).start();
new Thread(evenNumberGenerator).start();
}

}

OriginalL'auteur Victor

        public class OddAndEvenThreadProblems {
private static Integer i = 0;
public static void main(String[] args) {
new EvenClass().start();
new OddClass().start();
}
public static class EvenClass extends Thread {
public void run() {
while (i < 10) {
synchronized (i) {
if (i % 2 == 0 ) {
try {
Thread.sleep(1000);
System.out.println(" EvenClass " + i);
i = i + 1;
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
}
public static class OddClass extends Thread {
@Override
public void run() {
while (i < 10) {
synchronized (i) {
if (i % 2 == 1) {
try {
Thread.sleep(1000);
System.out.println(" OddClass  " + i);
i = i + 1;
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
}
}
OUTPUT will be :- 
EvenClass 0
OddClass  1
EvenClass 2
OddClass  3
EvenClass 4
OddClass  5
EvenClass 6
OddClass  7
EvenClass 8
OddClass  9