Programowanie współbieżne w języku Java

dr inż. Wojciech Kozioski kwiecieo 2010
Materiały pomocnicze do laboratorium
„Programowanie współbieżne w języku Java”
AiR, studia II stopnia, sem.1, piątek 14.15-16.00 GE 326
Testowanie czy sprzęt jest wielordzeniowy (Java Specialists’ Newsletter 135).
import java.lang.management.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
public class MultiCoreTester {
private static final int THREADS = 5;
private static CountDownLatch ct = new CountDownLatch(THREADS);
private static AtomicLong total = new AtomicLong();
public static void main(String[] args)
throws InterruptedException {
long elapsedTime = System.nanoTime();
for (int i = 0; i < THREADS; i++) {
Thread thread = new Thread() {
public void run() {
total.addAndGet(measureThreadCpuTime());
ct.countDown();
}
};
thread.start();
}
ct.await();
elapsedTime = System.nanoTime() - elapsedTime;
System.out.println("Total elapsed time " + elapsedTime);
System.out.println("Total thread CPU time " + total.get());
double factor = total.get();
factor /= elapsedTime;
System.out.printf("Factor: %.2f%n", factor);
}
private static long measureThreadCpuTime() {
ThreadMXBean tm = ManagementFactory.getThreadMXBean();
long cpuTime = tm.getCurrentThreadCpuTime();
long total=0;
for (int i = 0; i < 1000 * 1000 * 1000; i++) {
// keep ourselves busy for a while ...
// note: we had to add some "work" into the loop or Java 6
// optimizes it away. Thanks to Daniel Einspanjer for
// pointing that out.
total += i;
total *= 10;
}
cpuTime = tm.getCurrentThreadCpuTime() - cpuTime;
System.out.println(total + " ... " + Thread.currentThread() +
": cpuTime = " + cpuTime);
return cpuTime;
}
}
Przeprowadzenie badania z poziomu systemu operacyjnego. Ze środowiska rozwojowego
otrzymujemy dodatkowy narzut na wykonywane operacje. (?)
Lab. „Programowanie współbieżne w języku Java”
1

Prosty program zawierający dwa wątki (instrukcje niskopoziomowe), działanie mechanizmu
przerwao, wykorzystanie narzędzia Profiler z Netbeans IDE do obserwacji (Sun Java tutorial).
public class SimpleThreads {
public static long startTime = 0;
// Display a message, proceed by the name of current thread.
static void threadMessage (String message) {
String threadName = Thread.currentThread().getName();
long time = System.currentTimeMillis() - startTime;
System.out.format("%s: %d: %s%n", threadName, time, message);
}
private static class MessageLoop implements Runnable {
public void run() {
String importantInfo[] = {
"Message no.1", "Message no.2", "Message no.3", "Message no.4"
};
try {
for (int i = 0; i < importantInfo.length; i++) {
Thread.sleep(3500); // Pause for 3.5 seconds
threadMessage(importantInfo[i]);
}
} catch (InterruptedException e) {
threadMessage("I wasn't done!");
}
}
}
public static void main(String[] args) throws InterruptedException {
// delay in miliseconds before we interrupt MessageLoop thread
// default is one hour
long patience = 1000*60*60;
// If command line present gives patience in seconds
if (args.length > 0) {
try {
patience = Long.parseLong(args[0]) * 1000;
} catch (NumberFormatException e) {
System.err.println("Argument must be an integer.");
System.exit(1);
}
}
}
startTime = System.currentTimeMillis();
threadMessage("Starting MessageLoop thread - patience = "+
new Long(patience).toString());
Thread t = new Thread(new MessageLoop(),"myThread");
t.start();
threadMessage("Waiting for MessageLoop thread to finish.");
// loop until MessageLoop thread exits
while (t.isAlive()) {
threadMessage("Still waiting ...");
// wait maximum 1 second for MessageLoop thread to finish
t.join(1000);
if (((System.currentTimeMillis() - startTime) > patience) &&
t.isAlive()) {
threadMessage("Tired of waiting!");
t.interrupt();
t.join(); //Shouldn't be long now -- wait indefinetely
}
}
threadMessage("Finally - the end");
}
Lab. „Programowanie współbieżne w języku Java”
2

Zadanie, w którym występuje błąd współbieżności (Java Specialists’ Newsletter 155).
public class BankAccount {
private int balance;
public BankAccount(int balance) {
this.balance = balance;
}
public void deposit(int amount) {
balance += amount;
}
public void withdraw(int amount) {
deposit(-amount);
}
public int getBalance() {
return balance;
}
}
=================================================================
import java.util.concurrent.*;
public class BankAccountTest {
public static void main(String[] args) {
final BankAccount account = new BankAccount(1000);
for (int i = 0; i < 2; i++) {
new Thread() {
{
start();
}
}
}
public void run() {
while (true) {
account.deposit(100);
account.withdraw(100);
}
}
};
}
ScheduledExecutorService timer =
Executors.newSingleThreadScheduledExecutor();
timer.scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println(account.getBalance());
}
}, 1, 1, TimeUnit.SECONDS);
Użycie opcje kompilatora języka Java:
o -client hotspot
o -server hotspot (znacznie silniejsza optymalizacja kodu).
Wprowadzenie deklaracji volatile dla zmiennej balance z klasy BankAccount.
Wprowadzenie zmiennej typu AtomicInteger. w klasie BankAccount .
import java.util.concurrent.atomic.AtomicInteger;
public class BankAccount {
private final AtomicInteger balance =
new AtomicInteger();
}
public BankAccount(int balance) {
this.balance.set(balance);
}
public void deposit(int amount) {
balance.addAndGet(amount);
}
public void withdraw(int amount) {
deposit(-amount);
}
public int getBalance() {
return balance.intValue();
}
Lab. „Programowanie współbieżne w języku Java”
3

Liczba nieaktywnych wątków możliwa do utworzenia w systemie (Java Specialists’ Newsletter 149).
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.CountDownLatch;
public class ThreadCreationTest {
public static void main(String[] args)
throws InterruptedException {
final AtomicInteger threads_created = new AtomicInteger(0);
while (true) {
final CountDownLatch latch = new CountDownLatch(1);
new Thread() {
{ start(); }
public void run() {
latch.countDown();
synchronized (this) {
System.out.println("threads created: " +
threads_created.incrementAndGet());
try {
wait();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
};
latch.await();
}
}
}
Lab. „Programowanie współbieżne w języku Java”
4

Zakleszczenie (ang. Deadlock) (Java Specialists’ Newsletter 147). Aplikację należy uruchomid z
poziomu systemu operacyjnego.
public class BadClass extends Thread {
private final Object lock1;
private final Object lock2;
}
public BadClass(Object lock1, Object lock2) {
this.lock1 = lock1;
this.lock2 = lock2;
}
public void run() {
while(true) {
synchronized(lock1) {
synchronized(lock2) {
System.out.print('.');
System.out.flush();
}
}
}
}
public static void main(String[] args) {
Object lock1 = new Object();
Object lock2 = new Object();
BadClass bc1 = new BadClass(lock1, lock2);
BadClass bc2 = new BadClass(lock2, lock1);
bc1.start();
bc2.start();
}
Wyjście z zakleszczenia z generacją zrzutu:
Windows: Ctrl+Break
Unix: Ctrl+\ lub kill -3
Analiza zrzutu – informacja o zakleszczeniu.
Lab. „Programowanie współbieżne w języku Java”
5

Klasa Complex, która jest niezmienna (ang. immutable), stałe typu complex.
package cplx;
public final class Complex { // immutable class
private final double re;
private final double im;
public static final Complex ZERO = new Complex(0, 0);
public static final Complex ONE = new Complex(1, 0);
public static final Complex I = new Complex(0, 1);
public Complex(double re, double im) {
this.re = re;
this.im = im;
}
public double realPart() { return re; }
public double imagPart() { return im; }
}
public Complex add(Complex c) {
return new Complex(re + c.re, im + c.im);
}
public Complex subtract(Complex c) {
return new Complex(re - c.re, im - c.im);
}
public Complex multiply(Complex c) {
return new Complex(re * c.re - im * c.im,
re * c.im + im * c.re);
}
public Complex divide(Complex c) {
double tmp = c.re *c.re + c.im * c.im;
return new Complex((re * c.re + im * c.im)/tmp,
(im * c.re - re * c.im)/tmp);
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Complex)) return false;
Complex c = (Complex) o;
return Double.compare(re, c.re) == 0 &&
Double.compare(im, c.im) == 0;
}
@Override
public int hashCode() {
int result = 17 + hashDouble(re);
result = 31 * result + hashDouble(im);
return result;
}
private static int hashDouble(double val) {
long longBits = Double.doubleToLongBits(val);
return (int) (longBits ^ (longBits >>> 32));
}
@Override
public String toString() {
return "(" + re + " + " + im + "i)";
}
Lab. „Programowanie współbieżne w języku Java”
6

Niezmienna (ang. immutable) klasa Complex ze statycznymi konstruktorami
package cplxs;
public class Complex { // immutable class with static constructors
private final double re;
private final double im;
private Complex(double re, double im) {
this.re = re;
this.im = im;
}
public static Complex valueOf(double re, double im) {
return new Complex(re, im);
}
public static Complex valueOfPolar(double r , double theta) {
return new Complex(r * Math.cos(theta), r*Math.sin(theta));
}
public double realPart() { return re; }
public double imagPart() { return im; }
}
public Complex add(Complex c) {
return new Complex(re + c.re, im + c.im);
}
public Complex subtract(Complex c) {
return new Complex(re - c.re, im - c.im);
}
public Complex multiply(Complex c) {
return new Complex(re * c.re - im * c.im,
re * c.im + im * c.re);
}
public Complex divide(Complex c) {
double tmp = c.re *c.re + c.im * c.im;
return new Complex((re * c.re + im * c.im)/tmp,
(im * c.re - re * c.im)/tmp);
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (!(o instanceof Complex)) return false;
Complex c = (Complex) o;
return Double.compare(re, c.re) == 0 &&
Double.compare(im, c.im) == 0;
}
@Override
public int hashCode() {
int result = 17 + hashDouble(re);
result = 31 * result + hashDouble(im);
return result;
}
private static int hashDouble(double val) {
long longBits = Double.doubleToLongBits(val);
return (int) (longBits ^ (longBits >>> 32));
}
@Override
public String toString() {
return "(" + re + " + " + im + "i)";
}
Lab. „Programowanie współbieżne w języku Java”
7

Zadanie producent – konsument rozwiązywane w czterech wersjach.
Wersja 1
package prodcons01;
public class ProducerConsumerTest1 {
public static void main(String[] args) {
CubbyHole1 c = new CubbyHole1();
Producer1 p1 = new Producer1(c, 1);
Consumer1 c1 = new Consumer1(c, 1);
p1.start();
c1.start();
}
}
=============================================
package prodcons01;
public class Producer1 extends Thread {
private CubbyHole1 cubbyhole;
private int number;
public Producer1(CubbyHole1 c, int number) {
cubbyhole = c;
this.number = number;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
cubbyhole.put(number, i);
try {
sleep((int)(Math.random() * 500));
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
}
}
===================================================
package prodcons01;
public class Consumer1 extends Thread {
private CubbyHole1 cubbyhole;
private int number;
public Consumer1(CubbyHole1 c, int number) {
cubbyhole = c;
this.number = number;
}
@Override
public void run() {
int value = 0;
for (int i = 0; i < 10; i++) {
value = cubbyhole.get(number);
try {
sleep((int)(Math.random() * 1000));
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
}
}
Lab. „Programowanie współbieżne w języku Java”
8

package prodcons01;
public class CubbyHole1 {
private boolean available = false;
private int contents = 0;
public synchronized int get(int who) {
while (available == false) {
try {
//Wait for Producer to put value.
wait();
} catch (InterruptedException e) { }
}
available = false;
System.out.format("Consumer #%d got: %d%n", who, contents);
//Notify Producer that value has been retrieved.
notifyAll();
return contents;
}
}
public synchronized void put(int who, int value) {
while (available == true) {
try {
//Wait for Consumer to get value.
wait();
} catch (InterruptedException e) { }
}
contents = value;
available = true;
System.out.format("Producer #%d put: %d%n", who, contents);
//Notify Consumer that value has been set.
notifyAll();
}
Lab. „Programowanie współbieżne w języku Java”
9

Wersja 2
package prodcons2;
public class ProducerConsumerTest2 {
public static void main(String[] args) {
CubbyHole2 c = new CubbyHole2();
Producer1 p1 = new Producer1(c, 1);
Consumer1 c1 = new Consumer1(c, 1);
p1.start();
c1.start();
}
}
==============================================
package prodcons2;
public class Producer1 extends Thread {
private CubbyHole2 cubbyhole;
private int number;
public Producer1(CubbyHole2 c, int number) {
cubbyhole = c;
this.number = number;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
cubbyhole.put(number, i);
try {
sleep((int)(Math.random() * 500));
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
}
}
=================================================
package prodcons2;
public class Consumer1 extends Thread {
private CubbyHole2 cubbyhole;
private int number;
public Consumer1(CubbyHole2 c, int number) {
cubbyhole = c;
this.number = number;
}
@Override
public void run() {
int value = 0;
for (int i = 0; i < 10; i++) {
value = cubbyhole.get(number);
try {
sleep((int)(Math.random() * 1000));
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
}
}
=====================================================
Lab. „Programowanie współbieżne w języku Java”
10

package prodcons2;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class CubbyHole2 {
private int contents;
private boolean available = false;
private Lock aLock = new ReentrantLock();
private Condition condVar = aLock.newCondition();
public int get(int who) {
aLock.lock();
try {
while (available == false) {
try {
condVar.await();
} catch (InterruptedException e) { }
}
available = false;
System.out.format("Consumer %d got: %d%n", who, contents);
condVar.signalAll();
} finally {
aLock.unlock();
}
return contents;
}
}
public void put(int who, int value) {
aLock.lock();
try {
while (available == true) {
try {
condVar.await();
} catch (InterruptedException e) { }
}
contents = value;
available = true;
System.out.format("Producer %d put: %d%n", who, contents);
condVar.signalAll();
} finally {
aLock.unlock();
}
}
Lab. „Programowanie współbieżne w języku Java”
11

Wersja 3
package prodcons3;
import java.util.concurrent.ArrayBlockingQueue;
public class ProducerConsumerTest3 {
public static void main(String[] args) {
ArrayBlockingQueue c = new ArrayBlockingQueue(1);
Producer3 p1 = new Producer3(c, 1);
Consumer3 c1 = new Consumer3(c, 1);
p1.start();
c1.start();
}
}
======================================================
package prodcons3;
import java.util.concurrent.BlockingQueue;
public class Producer3 extends Thread {
private BlockingQueue cubbyhole;
private int number;
public Producer3(BlockingQueue c, int num) {
cubbyhole = c;
number = num;
}
public void run() {
for (int i = 0; i < 10; i++) {
try {
cubbyhole.put(i);
System.out.format("Producer #%d put: %d%n", number, i);
sleep((int)(Math.random() * 500));
} catch (InterruptedException e) { }
}
}
}
===========================================================
package prodcons3;
import java.util.concurrent.BlockingQueue;
public class Consumer3 extends Thread {
private BlockingQueue cubbyhole;
private int number;
public Consumer3(BlockingQueue c, int num) {
cubbyhole = c;
number = num;
}
}
public void run() {
int value = 0;
for (int i = 0; i < 10; i++) {
try {
value = cubbyhole.take();
System.out.format("Consumer #%d got: %d%n", number, value);
} catch (InterruptedException e) { }
}
}
Lab. „Programowanie współbieżne w języku Java”
12

Wersja 4
package prodcons04;
public class ProducerConsumerTest4 {
public static void main(String[] args) {
SemaphoreBoundedBuffer c = new SemaphoreBoundedBuffer(1);
Producer4 p1 = new Producer4(c, 1);
Consumer4 c1 = new Consumer4(c, 1);
p1.start();
c1.start();
}
}
==============================================================
package prodcons04;
public class Producer4 extends Thread {
private SemaphoreBoundedBuffer cubbyhole;
private int number;
public Producer4(SemaphoreBoundedBuffer c, int number) {
cubbyhole = c;
this.number = number;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
cubbyhole.put(number, i);
sleep((int)(Math.random() * 500));
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
}
}
================================================================
package prodcons04;
public class Consumer4 extends Thread {
private SemaphoreBoundedBuffer cubbyhole;
private int number;
public Consumer4(SemaphoreBoundedBuffer c, int number) {
cubbyhole = c;
this.number = number;
}
@Override
public void run() {
int value = 0;
for (int i = 0; i < 10; i++) {
try {
value = (Integer)(cubbyhole.take(number));
sleep((int)(Math.random() * 1000));
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
}
}
==================================================================
Lab. „Programowanie współbieżne w języku Java”
13

package prodcons04;
import java.util.concurrent.Semaphore;
public class SemaphoreBoundedBuffer {
private final Semaphore availableItems, availableSpaces;
private final E[] items;
private int putPosition = 0, takePosition = 0;
public SemaphoreBoundedBuffer(int capacity) {
if (capacity

Szkielety interfejsy Egzekutor do zarządzania wątkami, interfejs Callable oraz klasa Future
FixedThreadPoolExcecutor
package thp01;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolTest {
public static void main(String[] args) {
int numWorkers = Integer.parseInt(args[0]);
int threadPoolSize = Integer.parseInt(args[1]);
ExecutorService tpes = Executors.newFixedThreadPool(threadPoolSize);
WorkerThread[] workers = new WorkerThread[numWorkers];
for (int i = 0; i < numWorkers; i++) {
workers[i] = new WorkerThread(i);
tpes.execute(workers[i]);
}
tpes.shutdown();
}
}
======================================================================
package thp01;
public class WorkerThread implements Runnable {
private int workerNumber;
WorkerThread (int number) {
workerNumber = number;
}
}
public void run(){
for (int i = 0; i

Cached Executor oraz zadanie typu Callable.
package thp02;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ThreadPoolTest {
public static void main(String[] args) {
int numWorkers = Integer.parseInt(args[0]);
ExecutorService tpes = Executors.newCachedThreadPool();
CallableWorkerThread[] workers = new
CallableWorkerThread[numWorkers];
Future futures[] = new Future[numWorkers];
for (int i = 0; i < numWorkers; i++) {
workers[i] = new CallableWorkerThread(i);
futures[i] = tpes.submit(workers[i]);
}
for (int i = 0; i < numWorkers; i++) {
try {
System.out.format("Ending worker: %d%n", futures[i].get());
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
tpes.shutdown();
}
}
=========================================================================
package thp02;
import java.util.concurrent.Callable;
public class CallableWorkerThread implements Callable{
private int workerNumber;
CallableWorkerThread (int number) {
workerNumber = number;
}
}
public Integer call(){
for (int i = 0; i

Mnożenie macierzy – trzy wersje (książkowa – naiwna, z biblioteki Jama, wielowątkowa).
package mmold;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class MatrixMultiply02 {
public static void main(String[] args) {
int m = 6;
int n = 7;
int k = 8;
double[][] a = new double[m][n];
double[][] b = new double[n][k];
double[][] c = new double[m][k];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = 1.0D;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < k; ++j) {
b[i][j] = 1.0D;
}
}
System.out.println("=== First (naive method) test ===");
printMatrix(a, m, n, "A");
printMatrix(b, n, k, "B");
naiveMatrixMultiply(a, b, c);
printMatrix(c, m, k, "C");
System.out.println("=== Second (jama method) test ===");
printMatrix(a, m, n, "A");
printMatrix(b, n, k, "B");
jamaMatrixMultiply(a, b, c);
printMatrix(c, m, k, "C");
}
System.out.println("=== Third (threaded - Executors) test ===");
printMatrix(a, m, n, "A");
printMatrix(b, n, k, "B");
threadedMatrixMultiply(a, b, c, 2);
printMatrix(c, m, k, "C");
// book like method matrix multiplication - matrix indexing is very slow
static void naiveMatrixMultiply(final double[][] a, final double[][] b,
final double[][] c) {
// check(a,b,c); // checks for null args, incorrectly sized matrices,
etc.
final int m = a.length;
final int n = b.length;
final int p = b[0].length;
for (int j = 0; j < p; j++) {
for (int i = 0; i < m; i++) {
double s = 0;
for (int k = 0; k < n; k++) {
s += a[i][k] * b[k][j];
}
c[i][j] = s;
}
}
}
// Jama multiplication - much faster vector indexing than double array
indexing
static void jamaMatrixMultiply(final double[][] a, final double[][] b,
Lab. „Programowanie współbieżne w języku Java”
17

final double[][] c) {
// check(a,b,c);
final int m = a.length;
final int n = b.length;
final int p = b[0].length;
}
final double[] Bcolj = new double[n];
for (int j = 0; j < p; j++) {
for (int k = 0; k < n; k++) {
Bcolj[k] = b[k][j];
}
for (int i = 0; i < m; i++) {
final double[] Arowi = a[i];
double s = 0;
for (int k = 0; k < n; k++) {
s += Arowi[k] * Bcolj[k];
}
c[i][j] = s;
}
}
// Jama type method which uses several threads
static void threadedMatrixMultiply(final double[][] a, final double[][] b,
final double[][] c, final int numTasks) {
// check(a,b,c);
final int m = a.length;
final int n = b.length;
final int p = b[0].length;
final ExecutorService executor = Executors.newFixedThreadPool(numTasks);
for (int interval = numTasks, end = p, size = (int) Math.ceil(p * 1.0 /
numTasks);
interval > 0; interval--, end -= size) {
final int to = end;
final int from = Math.max(0, end - size);
final Runnable runnable = new Runnable() {
public void run() {
final double[] Bcolj = new double[n];
for (int j = from; j < to; j++) {
for (int k = 0; k < n; k++) {
Bcolj[k] = b[k][j];
}
for (int i = 0; i < m; i++) {
final double[] Arowi = a[i];
double s = 0;
for (int k = 0; k < n; k++) {
s += Arowi[k] * Bcolj[k];
}
c[i][j] = s;
}
}
}
};
executor.execute(runnable);
}
try {
executor.shutdown();
executor.awaitTermination(2, TimeUnit.DAYS); // O(n^3) can take a
while!
} catch (final InterruptedException e) {
System.out.println("Interrupted.");
// empty(c);
}
}
public static void printMatrix(double[][] A, int aRow, int aCol, String
str) {
System.out.println("Matrix " + str + " nRows = " + aRow + " nCols = " +
aCol);
Lab. „Programowanie współbieżne w języku Java”
18

}
}
for (int i = 0; i < aRow; i++) {
for (int j = 0; j < aCol; j++) {
System.out.print(A[i][j] + " ");
}
System.out.println();
}
System.out.println();
Lab. „Programowanie współbieżne w języku Java”
19