Java : 멀티 스레딩

Question

/* 제작자 만 실행하고 소비자가 아무것도 소비하지 않을 때마다 여기에서 무엇이 잘못 되었습니까? 이 코드에서 무엇이 잘못되었는지 설명해주십시오.

내 예상 결과

: 생산자 제작 한 항목은 다음 소비자가 해당 항목 *을 소비하는 당신이 sycnhronize 기다려 그렇지 객체 프로듀서를 들어, 사용 목록을 통지 할 필요가 모든/

import java.util.ArrayList; 

public class ConsumerAndProducerMain 
{ 
    public static void main(String[] args) throws InterruptedException 
    { 
     int MAX_SIZE = 10; 
     ArrayList<Integer> list = new ArrayList<Integer>(10); 
     final Producer producer = new Producer(MAX_SIZE, list); 
     final Consumer consumer = new Consumer(MAX_SIZE, list); 
     Thread t1 = new Thread(new Runnable() 
     { 
      @Override 
      public void run() 
      { 
       try 
       { 
        producer.producer(); 
       } 
       catch (InterruptedException e) 
       { 
        System.out.println("Producer : Exception occured because of multi threading..."); 
        e.printStackTrace(); 
       } 
      } 
     }); 
     Thread t2 = new Thread(new Runnable() 
     { 
      @Override 
      public void run() 
      { 
       try 
       { 
        consumer.consumer(); 
       } 
       catch (InterruptedException e) 
       { 
        System.out.println("Consumer : Exception occured because of multi threading..."); 
        e.printStackTrace(); 
       } 
      } 
     }); 
     t1.start(); 
     t2.start(); 
     t1.join(); 
     t2.join(); 
     System.out.println("Program terminated.."); 
    } 
} 

class Producer { 
    int size; 
    ArrayList<Integer> list; 
    public Producer(int size, ArrayList<Integer> list) 
    { 
     this.size = size; 
     this.list = list; 
    } 
    public void producer() throws InterruptedException{ 
     int value = 0; 
     while(true){ 
      synchronized (this) 
      { 
       if(list.size() == size){ 
        System.out.println("Producer : List is full"); 
        wait(); 
       }else{ 
        list.add(++value); 
        Thread.sleep(200); 
        notify(); 
        System.out.println("Value produce by the producer : "+value); 
       } 
      } 
     } 
    } 
} 

class Consumer { 
    int size; 
    ArrayList<Integer> list; 
    public Consumer(int size, ArrayList<Integer> list) 
    { 
     this.size = size; 
     this.list = list; 
    } 
    public void consumer() throws InterruptedException{ 
     while(true){ 
      synchronized (this) 
      { 
       if(list.isEmpty()){ 
        System.out.println("Consumer : List is empty"); 
        wait(); 
       }else{ 
        int removedItem = list.remove(list.size()); 
        Thread.sleep(5000); 
        notify(); 
        System.out.println("Value consumed by the consumer : "+removedItem); 
       } 
      } 
     } 
    } 
} 

Answer 1

첫 번째와 당신이하는 소비자.

프로듀서 :

final ArrayList<Integer> list; 
// ... 
synchronized (list) { 
    if (list.size() == size) { 
    System.out.println("Producer : List is full"); 
    list.wait(); 
    } else { 
    list.add(++value); 
    Thread.sleep(200); 
    list.notify(); 
    System.out.println("Value produce by the producer : " + value); 
    } 
} 

소비자 : 당신의 예상 결과 (1 개 항목은 다음 소비자가 소비하는 생산자의 생산을 위해

Value produce by the producer : 1 
Value produce by the producer : 2 
Value produce by the producer : 3 
Value produce by the producer : 4 
Value produce by the producer : 5 
Value produce by the producer : 6 
Value produce by the producer : 7 
Value produce by the producer : 8 
Value produce by the producer : 9 
Value produce by the producer : 10 
Producer : List is full 
Value consumed by the consumer : 10 
Value consumed by the consumer : 9 
Value consumed by the consumer : 8 
... 

:

final ArrayList<Integer> list; 
// ... 
synchronized (list) { 
    if (list.isEmpty()) { 
    System.out.println("Consumer : List is empty"); 
    list.wait(); 
    } else { 
    int removedItem = list.remove(list.size() - 1); 
    Thread.sleep(200); 
    list.notify(); 
    System.out.println("Value consumed by the consumer : " + removedItem); 
    } 
} 

출력의 모양입니다 item) wait의 순서로 로직을 변경하고 알림을해야합니다. 프로듀서가 항목을 추가하고 알림을 보내고 다음을 기다립니다. r Consumer notify, Consumer가 Producer notify를 기다리고 1 개 항목을 소비 한 다음 Producer notify를 다시 기다립니다.