8. 다중스레드

8.1 스레드 개요

대부분의 프로그래밍 언어에서는 다중 스레드를 구현하기 위해 시스템에 의존적인 프로시저나 함수를 호출하여 구현
하는 반면 자바 언어는 다중 스레드의 기능을 실행 시스템과는 상관없이 JVM에 내장된(Builtin)형태로 구현하고 있다.
이러한 이유로 자바 언어의 스레드를 경량 프로세스(light weight)라 한다.

In computer science, a thread of execution is the smallest unit of processing that can be scheduled by an operating system. It generally results from a fork of a computer program into two or more concurrently running tasks. The implementation of threads and processes differs from one operating system to another, but in most cases, a thread is contained inside a process. Multiple threads can exist within the same process and share resources such as memory, while different processes do not share these resources. In particular, the threads of a process share the latter's instructions (its code) and its context (the values the various variables have at any given moment). To give an analogy, multiple threads in a process are like multiple cooks reading off the same cook book and following its instructions, not necessarily from the same page.

On a single processor, multithreading generally occurs by time-division multiplexing (as in multitasking): the processor switches between different threads. This context switching generally happens frequently enough that the user perceives the threads or tasks as running at the same time. On a multiprocessor or multi-core system, the threads or tasks will actually run at the same time, with each processor or core running a particular thread or task.

Many modern operating systems directly support both time-sliced and multiprocessor threading with a process scheduler. The kernel of an operating system allows programmers to manipulate threads via the system call interface. Some implementations are called a kernel thread, whereas a lightweight process (LWP) is a specific type of kernel thread that shares the same state and information.

Programs can have user-space threads when threading with timers, signals, or other methods to interrupt their own execution, performing a sort of ad-hoc time-slicing. [위키피디아 참조]

8.2 Thread 클래스와 스레드 생명주기

 

8.3 스레드의 생성과 사용

자바에서 스레드를 생성하는 두가지 방법이 있다.
첫번째는 , Thread 클래스로부터 상속받아 스레드 특성을 가진 클래스를 생성하는 것이고,
두번째는 , Runnable 인터페이스를 이용하여 스레드를 사용하는 것이다.

// Thread class declaration
class ThreadA extends Thread {

public void run() {

// 수행 문장 작성

}

}

// Thead 객체 생성
ThreadA ta = new ThreadA();
ta.start();

public interface Runnable {

public void run();

}
// Runnable interface implements
class RunnableB extends Applet implements Runnable {

@override
public void run() {

// 수행 문장

}

}

// Thread 객체 생성
RunnableB rb = new RunnableB();
Thread tb = new Thread(rb);
tb.start();

 

class ThreadTest extends Thread{
 
 @Override
 public void run()
 {
  try {
   for (int i=0 ; i<10 ; i++)
   {
    Thread.sleep(200);
    System.out.println("fun java :" + i) ;
   }
  }
  catch(InterruptedException e)
  {
   System.out.println(e);
  }
 }
}

class ThreadfromThread {
 public static void main(String args[])
 {
  ThreadTest t = new ThreadTest();
  t.start();
 }
}

class ThreadTestA extends Thread{
 
 ThreadTestA(String s)
 {
  super(s);
 }
 @Override
 public void run()
 {
  try {
   for (int i=0 ; i<10 ; i++)
   {
    if (i%2==0)
    {
    Thread.sleep(1);
    System.out.println("fun java(A) :" + getName() + i) ;
   
    }
   }
  }
  catch(InterruptedException e)
  {
   System.out.println(e);
  }
 }
}

class ThreadTestB extends Thread{
 /*
 ThreadTestA(String s)
 {
  super(s);
 }*/
 @Override
 public void run()
 {
  try {
   for (int i=0 ; i<10 ; i++)
   {
    if (i%2==1)
    {
    Thread.sleep(1);
    System.out.println("fun java(B):" + i) ;
   
    }
   }
  }
  catch(InterruptedException e)
  {
   System.out.println(e);
  }
 }
}
class ThreadfromThread {
 public static void main(String args[])
 {
  ThreadTestA ta1 = new ThreadTestA("사랑한다");
  ThreadTestA ta2 = new ThreadTestA("안한다");
  ThreadTestB tb = new ThreadTestB();
  ta1.start();
  ta2.start();
  //tb.start();
 }
}

8.4 스레드 우선순위

class Priority extends Thread{
 public Priority(String str)
 {
  super(str);
 }
 
 public void run()
 {
  try {
   for (int i=0 ; i<10 ; i++)
   {
    Thread.sleep(10);
    System.out.println( i + getName() + " 우선순위 : " + getPriority());
    
   }
  }
  catch(InterruptedException e)
  {
   System.out.println(e);
  }
 }
}

public class ThreadPriority {
 public static void main(String args[])
 {
  Priority pt1 = new Priority("first");
  Priority pt2 = new Priority("second");
  Priority pt3 = new Priority("third");
  
  int priority_t1 = Integer.parseInt(args[0]);
  int priority_t2 = Integer.parseInt(args[1]);
  
  pt1.setPriority(priority_t1);
  pt2.setPriority(priority_t2);
  pt3.setPriority(Thread.MIN_PRIORITY);
  
  pt1.start();
  pt2.start();
  pt3.start();
 }
}

8.5 동기화

자바에서는 Critical Section 을 위한 synchronized 메소드를 제공한다.
lock을 얻고 양보하는 일은 JVM에 의해 자동적으로 수행되는 원자적인 동작이다.

class Account {
  private int total = 0 ;
  synchronized void deposit(int amount) {
   total += amount ;
  }
  int gettotal() {
   return total ;
  }
}

class Customer extends Thread {
 Account account1 ;
 Customer(Account account) {
  this.account1 = account ;
 }
 public void run() {
  try {
   for (int i=0 ; i<200 ; i++) {
    System.out.println("성금자 " + getName() + " : " + i + "번째");
    account1.deposit(1000);
    sleep(2);
    if (account1.gettotal() >=500000) break ;
   }
  }
  catch(Exception e) {
   System.out.println(e);
  }
 }
}

public class TVContribution {
 public static void main(String[] args) {
  Account account = new Account();
  
  Customer customers[] = new Customer[5];
  
  for (int i=0 ; i<5 ; i++) {
   customers[i] = new Customer(account);
   customers[i].start();
  }
  for (int i=0 ; i<5 ; i++) {
   try {
    customers[i].join();
   }
   catch(InterruptedException e) {
    e.printStackTrace();
   }
  }
  System.out.println("성금 총액은 : " + account.gettotal());
 }
}

8.6 스레드 사이의 통신

class Producer extends Thread {
 private Buffer blank ;
 
 Producer(Buffer blank) {
  this.blank = blank ;
 }
 
 public void run()
 {
  for (int i=0 ; i<10 ; i++)
  {
   blank.put(i);
   try {
    sleep((int)(Math.random()*100));
   }
   catch (InterruptedException e)
   {
    System.out.println(e);
   }
  }
 }
}

class Consumer extends Thread {
 private Buffer blank ;
 
 Consumer(Buffer c) {
  this.blank = c ;
 }
 
 public void run()
 {
  int value = 0 ;
  for (int i=0 ; i<10 ; i++)
  {
   value = blank.get();
  }
 }
}

class Buffer {
 private int contents ;
 private boolean available = false ;
 
 public synchronized int get()
 {
  while (available==false)
  {
   try {
    wait();
   }catch(InterruptedException e){};
   
  }
 
  System.out.println("소비자########### : 소비 " + contents);
  notify();
  available=false ;
 
  return contents ;
 }
 
 public synchronized void put(int value) {
  while (available==true) {
   try {
    wait();
   } catch(InterruptedException e){};
  }
  contents = value ;
  System.out.println("생산자########### : 생산 " + contents);
  notify();
  available=true ;
 
 }
 
}

public class ProducerConsumer {
 public static void main(String[] args) {

  Buffer c = new Buffer();
  Producer p1 = new Producer(c);
  Consumer c1 = new Consumer(c);
  
  p1.start();
  c1.start();

 }

}