Java 검토를 기반으로 멀티 스레드 동기화 사용에 대한 자세한 설명

공개 무효 실행()
{
System.out.println(Thread.currentThread().getName() + " 시작.");
for (int i = 1; i <= 100; i++)
{
합계 += i;
}
노력하다 {
Thread.sleep(500);
} 잡기(InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " --- sum 값은 " + sum);
System.out.println(Thread.currentThread().getName() + " 끝.");
}
}

private static void sharedVaribleTest()가 InterruptedException을 발생시킵니다.
{
MyRunner 러너 = new MyRunner();
스레드 thread1 = 새 스레드(러너);
스레드 thread2 = 새 스레드(러너);
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}

private static void syncTest()에서 InterruptedException이 발생합니다.
{
MyNonSyncRunner 러너 = new MyNonSyncRunner();
스레드 thread1 = 새 스레드(러너);
스레드 thread2 = 새 스레드(러너);
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}

private static void sharedVaribleTest3()에서 InterruptedException이 발생합니다.
{
MyRunner2 러너 = new MyRunner2();
스레드 thread1 = 새 스레드(러너);
스레드 thread2 = 새 스레드(러너);
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}

공개 무효 실행()
{
System.out.println(Thread.currentThread().getName() + " 시작.");
for (int i = 0; i <= 100; i++)
{
if (tl.get() == null)
{
tl.set(새 정수(0));
}
int sum = ((Integer)tl.get()).intValue();
합계+= i;
tl.set(새 정수(합계));
노력하다 {
Thread.sleep(10);
} 잡기(InterruptedException e) {
e.printStackTrace();
}
}

System.out.println(Thread.currentThread().getName() + " --- sum 값은 " + ((Integer)tl.get()).intValue());
System.out.println(Thread.currentThread().getName() + " 끝.");
}
}

private static void sharedVaribleTest4()가 InterruptedException을 발생시킵니다.
{
MyRunner3 러너 = new MyRunner3();
스레드 thread1 = 새 스레드(러너);
스레드 thread2 = 새 스레드(러너);
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}

private static void syncTest2()에서 InterruptedException이 발생합니다.
{
MySyncRunner 러너 = new MySyncRunner();
스레드 thread1 = 새 스레드(러너);
스레드 thread2 = 새 스레드(러너);
thread1.setDaemon(true);
thread2.setDaemon(true);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
}

스레드 thread1 = 새 스레드()
{
공개 무효 실행()
{
System.out.println(Thread.currentThread().getName() + " 시작.");
무작위 r = 새로운 무작위(100);
동기화됨(목록)
{
for (int i = 0; i < 5; i++)
{
list.add(new Integer(r.nextInt()));
}
System.out.println("목록의 크기는 " + list.size());
}
노력하다
{
Thread.sleep(500);
}
catch(InterruptedException ex)
{
ex.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 끝.");
}
};

스레드 thread2 = 새 스레드()
{
공개 무효 실행()
{
System.out.println(Thread.currentThread().getName() + " 시작.");
무작위 r = 새로운 무작위(100);
동기화됨(목록)
{
for (int i = 0; i < 5; i++)
{
list.add(new Integer(r.nextInt()));
}
System.out.println("목록의 크기는 " + list.size());
}
노력하다
{
Thread.sleep(500);
}
catch(InterruptedException ex)
{
ex.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " 끝.");
}
};

thread1.start();
thread2.start();
thread1.join();
thread2.join();
}

열거형 ThreadTask
{
시작,
멈추다,
잠,
깨우다
}

MyThread 클래스는 Thread를 확장합니다.
{
공개 ThreadStatus 상태 = ThreadStatus.Initial;
공개 ThreadTask 작업;
공개 무효 실행()
{
상태 = ThreadStatus.Running;
동안(사실)
{
노력하다 {
Thread.sleep(3000);
if (상태 == ThreadStatus.Sleeping)
{
System.out.println(Thread.currentThread().getName() + "절전 상태로 들어갑니다.");
this.wait();
}
} 잡기(InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "작업 중 오류가 발생했습니다.");
상태 = ThreadStatus.Stopped;
}
}
}
}

공개 정적 무효 관리Thread(MyThread 스레드, ThreadTask 작업)
{
if (작업 == ThreadTask.Start)
{
if (thread.status == ThreadStatus.Running)
{
반품;
}
if (thread.status == ThreadStatus.Stopped)
{
스레드 = 새로운 MyThread();
}
thread.status = ThreadStatus.Running;
thread.start();

}
else if(작업 == ThreadTask.Stop)
{
if (thread.status != ThreadStatus.Stopped)
{
스레드.인터럽트();
thread.status = ThreadStatus.Stopped;
}
}
else if(작업 == ThreadTask.Sleep)
{
thread.status = ThreadStatus.Sleeping;
}
else if(작업 == ThreadTask.Wakeup)
{
thread.notify();
thread.status = ThreadStatus.Running;
}
}

공개 정적 문자열 getThreadStatus(MyThread[] 스레드)
{
StringBuffer sb = new StringBuffer();
for (int i = 0; i < thread.length; i++)
{
sb.append(threads[i].getName() + "상태: " + 스레드[i].status).append("/r/n");
}
sb.toString()을 반환합니다.
}
}

public static void main(String[] args)에서 IOException이 발생합니다.
{
MyThreadPool 풀 = new MyThreadPool(5);
}

개인 int threadCount;
개인 MyThread[] 스레드 = null;

public MyThreadPool(int count)가 IOException을 발생시킵니다.
{
this.threadCount = 개수;
스레드 = 새로운 MyThread[개수];
for (int i = 0; i < thread.length; i++)
{
스레드[i] = new MyThread();
스레드[i].start();
}
초기화();
}

private void Init()가 IOException을 발생시킵니다.
{
ServerSocket serverSocket = 새 ServerSocket(5678);
동안(사실)
{
최종 소켓 소켓 = serverSocket.accept();
스레드 스레드 = 새 스레드()
{
공개 무효 실행()
{
노력하다
{
System.out.println("새 소켓 연결이 감지되었습니다.");
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintStream ps = new PrintStream(socket.getOutputStream());
문자열 라인 = null;
while((line = br.readLine()) != null)
{
System.out.println(line);
if (line.equals("개수"))
{
System.out.println("스레드 풀에 5개의 스레드가 있습니다.");
}
else if (line.equals("상태"))
{
문자열 상태 = MyThreadManager.getThreadStatus(threads);
System.out.println(상태);
}
else if (line.equals("StartAll"))
{
MyThreadManager.manageThread(스레드, ThreadTask.Start);
}
else if (line.equals("StopAll"))
{
MyThreadManager.manageThread(스레드, ThreadTask.Stop);
}
else if (line.equals("SleepAll"))
{
MyThreadManager.manageThread(스레드, ThreadTask.Sleep);
}
else if (line.equals("WakeupAll"))
{
MyThreadManager.manageThread(스레드, ThreadTask.Wakeup);
}
else if (line.equals("End"))
{
부서지다;
}
또 다른
{
System.out.println("명령:" + line);
}
ps.println("확인");
ps.flush();
}
}
catch(예외예외)
{
ex.printStackTrace();
}
}
};
thread.start();
}
}
}

MyRunner 러너 = new MyRunner();

final ScheduledFuture<?> handler1 = Scheduler.scheduleAtFixedRate(runner, 1, 10, TimeUnit.SECONDS);
final ScheduledFuture<?> handler2 = Scheduler.scheduleWithFixedDelay(runner, 2, 10, TimeUnit.SECONDS);

Scheduler.schedule(새로운 Runnable()
{
공개 무효 실행()
{
handler1.cancel(true);
handler2.cancel(true);
스케줄러.shutdown();
}
}, 30, TimeUnit.SECONDS
);
}

Thread.sleep(1000);
for(int i = 0; i < 10; i++)
{
Future<String> 결과 = service.take();
System.out.println("스레드의 반환 값은 " + result.get());
}
exec.shutdown();
}

공개 정적 무효 메인(문자열[] 인수)
{
BlockingQueueTest();
}

개인 정적 무효 BlockingQueueTest()
{
final BlockingQueue<Integer> 대기열 = new LinkedBlockingQueue<Integer>();
최종 int maxSleepTimeForSetter = 10;
최종 int maxSleepTimerForGetter = 10;

실행 가능 설정자 = 새로운 Runnable()
{
공개 무효 실행()
{
무작위 r = 새로운 무작위();
동안(사실)
{
int 값 = r.nextInt(100);
노력하다
{
queue.put(new Integer(값));
System.out.println(Thread.currentThread().getName() + "---큐에 값 삽입" + value);
Thread.sleep(r.nextInt(maxSleepTimeForSetter) * 1000);
}
catch(예외예외)
{
ex.printStackTrace();
}
}
}
};

실행 가능한 getter = 새로운 Runnable()
{
공개 무효 실행()
{
무작위 r = 새로운 무작위();
동안(사실)
{
노력하다
{
if (queue.size() == 0)
{
System.out.println(Thread.currentThread().getName() + "---큐가 비어 있습니다.");
}
또 다른
{
int 값 = queue.take().intValue();
System.out.println(Thread.currentThread().getName() + "---큐에서 값 가져오기" + value);
}
Thread.sleep(r.nextInt(maxSleepTimerForGetter) * 1000);
}
catch(예외예외)
{
ex.printStackTrace();
}
}
}
};

ExecutorService exec = Executors.newFixedThreadPool(2);
exec.execute(세터);
exec.execute(getter);
}
}

for (int i = 0; i < 10; i++)
{
실행 가능한 러너 = 새로운 Runnable()
{
공개 무효 실행()
{
노력하다
{
semp.acquire();
System.out.println(new Date() + " " + Thread.currentThread().getName() + "실행 중.");
Thread.sleep(5000);
semp.release();
}
catch(예외예외)
{
ex.printStackTrace();
}
}
};
exec.execute(러너);
}

exec.shutdown();
}

공개 무효 실행() {
무작위 r = 새로운 무작위();
노력하다
{
for (int i = 0; i < 3; i++)
{
Thread.sleep(r.nextInt(10) * 1000);
System.out.println(new Date() + "--" + Thread.currentThread().getName() + "--th" + (i + 1) + "wait.");
Barrier.await();
}
}
catch(예외예외)
{
ex.printStackTrace();
}
}

}

개인 정적 무효 cyclBarrierTest()
{
CyclicBarrier 장벽 = new CyclicBarrier(3);

ExecutorService exec = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++)
{
exec.execute(new MyRunner2(barrier));
}
exec.shutdown();
}