[] b, int off, int len)

The[] b, int off, int len) method reads upto len bytes of data from the input stream into an array of bytes. If the parameter len is zero, then no bytes are read and 0 is returned; else there is an attempt to read at least one byte. If the stream is at the end of the file, the value returned is -1.


  • b − The destination byte array.
  • off − The start offset in array b at which the data is written.
  • len − The number of bytes to read.

Return Value

The method returns the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.


  • IOException − If an I/O error occurs.
  • NullPointerException − If b is null.
  • IndexOutOfBoundsException − If off is negative, len is negative, or len is greater than b.length – off.



Lab8_1 ~ Lab8_6 코드 분석 보고서 (장수제한없음)를 넣고 Lab8_학번_이름.zip 압축한 후 e-learning (으로 제출 (Due by 12/10)


Lab8_1 TCP Client/Server
Lab8_2 UDP Client/Server
Lab8_3 HTTP (GET vs POST)
Lab8_4 ImageTransfer 1 image Client -> Server (using TCP)
Lab8_4 ImageDownloader 1 image Server -> Client (using TCP)
Lab8_4 ImageDownloaderWithFilename 1 image Server -> Client (using TCP)
Lab8_4 MultipleImageTransfer 20 images Client -> Server (using TCP)
Lab8_4 ThreadedMultipleImageTransfer 20 images Client -> Server (using TCP & # of threads)
Lab8_5 NetworkAnimatedImageViewFX (JavaFX, Thread, Network)
Lab8_6 Chat (JavaFX, Thread, TCP Reflector)


Lab7_1 ~ Lab7_5 코드 분석 보고서 (장수제한없음)를 넣고 Lab7_학번_이름.zip 압축한 후 e-learning (으로 제출 (Due by 12/3)


Lab7_1 extends Thread vs implements Runnable
Lab7_2 Monitor vs Mutex vs Semaphore
Lab7_3 TicketSeller (Monitor vs Mutex vs Semaphore)
Lab7_4 Producer-Consumer Problem (Monitor vs Semaphore)
Lab7_5 WorkerThread (JavaFX + Task) & ThreadedImageGrayscale (Performance by # of threads)

Producer-Consumer Problem

Producer-Consumer Problem using Semaphore

Producer() {

put(item) {

P(empty); // for wait, Get an empty count, block if unavailable
P(mutex); // lock critical section: shared buffer
<<< critical section: Put item into shared buffer >>>
V(mutex); // unlock critical section
V(full); // for signal, increase number of full count



Consumer() {

take () {

P(full); // for wait, Get a full count, block if unavailable
<<< critical section: Take item from shared buffer >>>
V(empty); // for signal, increase number of empty count
return item;



Producer-Consumer Problem using Monitor

Producer() {

synchronized put(item) {

while(count >= buffer.length) { wait(); } // wait if buffer is full
<<< critical section: Put iteminto shared buffer >>>
notifyAll(); // signal



Consumer() {

synchronized take () {

while(count <=0) { wait(); } // wait if buffer is empty
count- –
<<< critical section: Take itemfrom shared buffer >>>
notifyAll(); // signal
return item;



Java Thread yield() vs join() vs sleep()

We can prevent a thread from execution by using any of the 3 methods of Thread class:

  • yield()
  • join()
  • sleep()

yield() method pauses the currently executing thread temporarily for giving a chance to the remaining waiting threads of the same priority to execute. If there is no waiting thread or all the waiting threads have a lower priority then the same thread will continue its execution. The yielded thread when it will get the chance for execution is decided by the thread scheduler whose behavior is vendor dependent (i.e., yield() can only make a heuristic attempt to suspend the execution of the current thread with no guarantee of when will it be scheduled back).

join() The current thread can invoke join() on any other thread which makes the current thread wait for the other thread to die before proceeding. If any executing thread t1 calls join() on t2 (i.e, t2.join()) immediately t1 will enter into waiting state until t2 completes its execution.

sleep() method can force the scheduler to suspend the execution of the current thread for a specified period of time as its parameter.

Java Thread Synchronization

Thread Synchronization

  • Mutex Semaphore (aka Mutex) controls only one thread at a time executing on the shared resource by lock & unlock.
  • Counting Semaphore (aka Semaphore – Java7) controls the number of threads executing on the shared resource by acquire & release.
  • Monitor controls only one thread at a time, and can execute in the monitor (shared object) by wait & notify/notifyAll.