Java  public class ThreadExample {
public static void main (String[] args) {
MyThread thread = new MyThread();
thread.start();
Thread thread2 = new MyThread();
thread2.start();
System.out.println(Thread.currentThread()
.getName());
}
private static class MyThread extends Thread {
@Override
public void run () {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread()
.getName() + ": " + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class ThreadRunnableExample {
public static void main (String[] args) {
MyThreadRunner threadRunnable = new MyThreadRunner();
Thread thread = new Thread(threadRunnable);
thread.start();
MyThreadRunner threadRunnable2 = new MyThreadRunner();
Thread thread2 = new Thread(threadRunnable2);
thread2.start();
System.out.println(Thread.currentThread()
.getName());
}
private static class MyThreadRunner implements Runnable {
@Override
public void run () {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread()
.getName() + ": " + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class MemoryWatcherThread implements Runnable {
public static void start () {
Thread thread = new Thread(new MemoryWatcherThread());
thread.setPriority(Thread.MAX_PRIORITY);
thread.setDaemon(true);
thread.start();
}
@Override
public void run () {
long memoryUsed = getMemoryUsed();
System.out.println("Memory used :" + memoryUsed + " MB");
while (true) {
long memoryUsed1 = getMemoryUsed();
if (memoryUsed != memoryUsed1) {
memoryUsed = memoryUsed1;
System.out.println("Memory used :" + memoryUsed + " MB");
}
}
}
private long getMemoryUsed () {
return (Runtime.getRuntime()
.totalMemory() - Runtime.getRuntime()
.freeMemory()) / 1024 / 1024;
}
}
Thread priority example. public class ThreadPriorityExample {
public static void main (String[] args) {
MyThread thread = new MyThread();
thread.setName("thread 1");
thread.setPriority(Thread.MIN_PRIORITY);
thread.start();
Thread thread2 = new MyThread();
thread2.setName("thread 2");
thread2.setPriority(Thread.MAX_PRIORITY);
thread2.start();
}
private static class MyThread extends Thread {
private int c;
@Override
public void run () {
String threadName = Thread.currentThread()
.getName();
System.out.println(threadName + " started.");
for (int i = 0; i < 1000; i++) {
c++;
try {
TimeUnit.MICROSECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(threadName + " ended.");
}
}
}
Thread#yield() example. public class ThreadYieldExample {
public static void main (String[] args) {
Task task1 = new Task(true);
new Thread(task1).start();
Task task2 = new Task(false);
new Thread(task2).start();
}
private static class Task implements Runnable {
private final boolean shouldYield;
private int c;
public Task(boolean shouldYield){
this.shouldYield = shouldYield;
}
@Override
public void run () {
String threadName = Thread.currentThread()
.getName();
System.out.println(threadName + " started.");
for (int i = 0; i < 1000; i++) {
c++;
if(shouldYield){
Thread.yield();
}
}
System.out.println(threadName + " ended.");
}
}
}
Thread#join() example. public class ThreadJoinExample {
public static void main (String[] args) throws InterruptedException {
Task task1 = new Task();
Thread thread1 = new Thread(task1);
thread1.start();
thread1.join();//here the main thread will wait until thread1 fishes.
System.out.println("after join");
Task task2 = new Task();
new Thread(task2).start();
}
private static class Task implements Runnable {
@Override
public void run () {
int c = 0;
String threadName = Thread.currentThread()
.getName();
System.out.println(threadName + " started.");
for (int i = 0; i < 1000; i++) {
c+=i;
}
System.out.println(threadName + " ended.");
}
}
}
Thread#join() example public class ThreadJoinExample2 {
public static void main (String[] args) {
final List<Integer> integers = Arrays.asList(10, 12, 13, 14, 15, 20);
new Thread(new Runnable() {
@Override
public void run () {
List<FactorialCalculator> threads = new ArrayList<>();
for (Integer integer : integers) {
FactorialCalculator calc = new FactorialCalculator(integer);
threads.add(calc);
calc.start();
}
for (FactorialCalculator calc : threads) {
try {
calc.join();
System.out.println(calc.getNumber() + "! = " + calc.getFactorial());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
private static class FactorialCalculator extends Thread {
private final int number;
private BigDecimal factorial;
FactorialCalculator (int number) {
this.number = number;
}
@Override
public void run () {
factorial = calculateFactorial(number);
}
private static BigDecimal calculateFactorial (int number) {
BigDecimal factorial = BigDecimal.ONE;
for (int i = 1; i <= number; i++) {
factorial = factorial.multiply(new BigDecimal(i));
}
return factorial;
}
public BigDecimal getFactorial () {
return factorial;
}
public int getNumber () {
return number;
}
}
}
Thread#interrup() example. public class ThreadInterruptExample {
public static void main (String[] args) throws InterruptedException {
Task task1 = new Task();
Thread thread1 = new Thread(task1);
thread1.start();
while (true){
if(Math.random()>0.5){
thread1.interrupt();
break;
}
TimeUnit.MILLISECONDS.sleep(1);
}
}
private static class Task implements Runnable {
@Override
public void run () {
int c = 0;
while (true) {
System.out.println("task running .. " + ++c);
if (Thread.currentThread()
.isInterrupted()) {
System.out.println("interrupted flag=true");
terminate();
return;
}
try {
TimeUnit.MICROSECONDS.sleep(1);
} catch (InterruptedException e) {
System.out.println("interrupted exception ");
terminate();
return;
}
}
}
private void terminate () {
System.out.println("Terminating task");
}
}
}
Thread#interrupt example public class ThreadInterruptSwingDemo {
public static void main (String[] args) {
JFrame frame = new JFrame("Interrupt Demo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(new Dimension(500, 500));
frame.add(createAnimationContainer());
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
private static Component createAnimationContainer () {
JPanel panel = new JPanel(new BorderLayout());
AnimatedPanel animatedPanel = new AnimatedPanel();
panel.add(animatedPanel);
JButton button = new JButton("Reverse");
panel.add(button, BorderLayout.SOUTH);
button.addActionListener(e -> {
animatedPanel.getThread().interrupt();
});
return panel;
}
private static class AnimatedPanel extends JComponent {
private int angle = 0;
boolean clockwise = true;
private Thread thread;
AnimatedPanel () {
startAnimation();
}
private void startAnimation () {
thread = new Thread(() -> {
while (true) {
angle++;
if (angle >= 360) {
angle = 0;
}
if(thread.isInterrupted()){
clockwise = !clockwise;
}
//no need to create EDT
repaint();
try {
TimeUnit.MILLISECONDS.sleep(10);
} catch (InterruptedException e) {
clockwise = !clockwise;
}
}
});
thread.start();
}
@Override
public void paint (Graphics g) {
g.setColor(Color.MAGENTA);
g.fillArc(10, 10, 400, 400, clockwise? -angle: angle, 30 );
}
public Thread getThread () {
return thread;
}
}
}
Thread synchronized method example public class ThreadSynchronizedDemo {
private Integer counter = 0;
public static void main (String[] args) throws InterruptedException {
ThreadSynchronizedDemo demo = new ThreadSynchronizedDemo();
Task task1 = demo.new Task();
Thread thread1 = new Thread(task1);
Task task2 = demo.new Task();
Thread thread2 = new Thread(task2);
thread1.start();
thread2.start();
}
private synchronized void performTask () {
int temp = counter;
counter++;
System.out.println(Thread.currentThread()
.getName() + " - before: "+temp+" after:" + counter);
}
private class Task implements Runnable {
@Override
public void run () {
for (int i = 0; i < 5; i++) {
performTask();
}
}
}
}
Thread synchronized static method example. public class ThreadSynchronizedStaticDemo {
private static Integer counter = 0;
public static void main (String[] args) throws InterruptedException {
Task task1 = new Task();
Thread thread1 = new Thread(task1);
Task task2 = new Task();
Thread thread2 = new Thread(task2);
thread1.start();
thread2.start();
}
private static void performTask () {
int temp = counter;
counter++;
System.out.println(Thread.currentThread()
.getName() + " - before: "+temp+" after:" + counter);
}
private static class Task implements Runnable {
@Override
public void run () {
for (int i = 0; i < 5; i++) {
performTask();
}
}
}
}
Thread interference example public class ThreadInterferenceDemo {
private Integer counter = 0;
public static void main (String[] args) throws InterruptedException {
ThreadInterferenceDemo demo = new ThreadInterferenceDemo();
Task task1 = demo.new Task();
Thread thread1 = new Thread(task1);
Task task2 = demo.new Task();
Thread thread2 = new Thread(task2);
thread1.start();
thread2.start();
}
private void performTask () {
int temp = counter;
counter++;
System.out.println(Thread.currentThread()
.getName() + " - before: " + temp + " after:" + counter);
}
private class Task implements Runnable {
@Override
public void run () {
for (int i = 0; i < 5; i++) {
performTask();
}
}
}
}
Thread synchronized method example public class ThreadSynchronizedDemo {
private Integer counter = 0;
public static void main (String[] args) throws InterruptedException {
ThreadSynchronizedDemo demo = new ThreadSynchronizedDemo();
Task task1 = demo.new Task();
Thread thread1 = new Thread(task1);
Task task2 = demo.new Task();
Thread thread2 = new Thread(task2);
thread1.start();
thread2.start();
}
private synchronized void performTask () {
int temp = counter;
counter++;
System.out.println(Thread.currentThread()
.getName() + " - before: "+temp+" after:" + counter);
}
private class Task implements Runnable {
@Override
public void run () {
for (int i = 0; i < 5; i++) {
performTask();
}
}
}
}
import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;
public class MultipleSyncMethodsDemo {
public static void main (String[] args) throws InterruptedException {
MultipleSyncMethodsDemo demo = new MultipleSyncMethodsDemo();
Thread thread1 = new Thread(() -> {
System.out.println("thread1 before call " + LocalDateTime.now());
demo.syncMethod1("from thread1");
System.out.println("thread1 after call " + LocalDateTime.now());
});
Thread thread2 = new Thread(() -> {
System.out.println("thread2 before call " + LocalDateTime.now());
demo.syncMethod2("from thread2");
System.out.println("thread2 after call " + LocalDateTime.now());
});
thread1.start();
thread2.start();
}
private synchronized void syncMethod1 (String msg) {
System.out.println("in the syncMethod1 " + msg + " " + LocalDateTime.now());
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private synchronized void syncMethod2 (String msg) {
System.out.println("in the syncMethod2 " + msg + " " + LocalDateTime.now());
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;
public class ThreadLockDemo {
public static void main (String[] args) throws InterruptedException {
ThreadLockDemo demo = new ThreadLockDemo();
Thread thread1 = new Thread(() -> {
System.out.println("thread1 before call "+ LocalDateTime.now());
demo.syncMethod("from thread1");
System.out.println("thread1 after call "+LocalDateTime.now());
});
Thread thread2 = new Thread(() -> {
System.out.println("thread2 before call "+LocalDateTime.now());
demo.syncMethod("from thread2");
System.out.println("thread2 after call "+LocalDateTime.now());
});
thread1.start();
thread2.start();
}
private synchronized void syncMethod (String msg) {
System.out.println("in the sync method "+msg+" "+LocalDateTime.now());
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;
public class ThreadStaticSyncDemo {
public static void main (String[] args) throws InterruptedException {
Thread thread1 = new Thread(() -> {
System.out.println("thread1 before call "+ LocalDateTime.now());
syncMethod("from thread1");
System.out.println("thread1 after call "+LocalDateTime.now());
});
Thread thread2 = new Thread(() -> {
System.out.println("thread2 before call "+LocalDateTime.now());
syncMethod("from thread2");
System.out.println("thread2 after call "+LocalDateTime.now());
});
thread1.start();
thread2.start();
}
private static synchronized void syncMethod (String msg) {
System.out.println("in the sync method "+msg+" "+LocalDateTime.now());
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;
public class ReentrantDemo {
public static void main (String[] args) throws InterruptedException {
ReentrantDemo demo = new ReentrantDemo();
Thread thread1 = new Thread(() -> {
System.out.println("thread1 before call " + LocalDateTime.now());
demo.syncMethod1("from thread1");
System.out.println("thread1 after call " + LocalDateTime.now());
});
Thread thread2 = new Thread(() -> {
System.out.println("thread2 before call " + LocalDateTime.now());
demo.syncMethod2("from thread2");
System.out.println("thread2 after call " + LocalDateTime.now());
});
thread1.start();
thread2.start();
}
private synchronized void syncMethod1 (String msg) {
System.out.println("in the syncMethod1 " + msg + " " + LocalDateTime.now());
syncMethod2("from method syncMethod1, reentered call");
}
private synchronized void syncMethod2 (String msg) {
System.out.println("in the syncMethod2 " + msg + " " + LocalDateTime.now());
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Synchronized block Example import java.util.ArrayList;
import java.util.List;
public class LazyInitBlockDemo {
private volatile List<String> list;
public static void main (String[] args) throws InterruptedException {
LazyInitBlockDemo obj = new LazyInitBlockDemo();
Thread thread1 = new Thread(() -> {
System.out.println("thread1 : " + System.identityHashCode(obj.getList()));
});
Thread thread2 = new Thread(() -> {
System.out.println("thread2 : " + System.identityHashCode(obj.getList()));
});
thread1.start();
thread2.start();
}
private List<String> getList () {
if (list == null) {
synchronized (this) {
if(list == null) {
list = new ArrayList<>();
}
}
}
return list;
}
}
Synchronized block Example import java.util.ArrayList;
import java.util.List;
public class MultipleLocksDemo {
private volatile List<String> list1;
private volatile List<String> list2;
private final Object lock1 = new Object();
private final Object lock2 = new Object();
public static void main (String[] args) throws InterruptedException {
MultipleLocksDemo obj = new MultipleLocksDemo();
Thread thread1 = new Thread(() -> {
System.out.println("thread1 list1 : " + System.identityHashCode(obj.getList1()));
System.out.println("thread1 list2 : " + System.identityHashCode(obj.getList2()));
});
Thread thread2 = new Thread(() -> {
System.out.println("thread2 list1 : " + System.identityHashCode(obj.getList1()));
System.out.println("thread2 list2 : " + System.identityHashCode(obj.getList2()));
});
thread1.start();
thread2.start();
}
private List<String> getList1 () {
if (list1 == null) {
synchronized (lock1) {
if (list1 == null) {
list1 = new ArrayList<>();
}
}
}
return list1;
}
private List<String> getList2 () {
if (list2 == null) {
synchronized (lock2) {
if (list2 == null) {
list2 = new ArrayList<>();
}
}
}
return list2;
}
}
Synchronized block Example import java.util.ArrayList;
import java.util.List;
public class MultipleLocksDemo2 {
private List<String> list1 = new ArrayList<>();
private List<String> list2 = new ArrayList<>();
public static void main (String[] args) {
MultipleLocksDemo2 obj = new MultipleLocksDemo2();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
obj.addToList1("thread1 list1 element=" + i);
obj.addToList2("thread1 list2 element=" + i);
obj.printLists();
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
obj.addToList1("thread2 list1 element=" + i);
obj.addToList2("thread2 list2 element 2" + i);
obj.printLists();
}
});
thread1.start();
thread2.start();
}
public void addToList1 (String s) {
synchronized (list1) {
list1.add(s);
}
}
public void addToList2 (String s) {
synchronized (list2) {
list2.add(s);
}
}
public void printLists () {
String name = Thread.currentThread()
.getName();
synchronized (list1) {
list1.stream()
.forEach(l -> System.out.println(name + " : " + l));
}
synchronized (list2) {
list2.stream()
.forEach(l -> System.out.println(name + " : " + l));
}
}
}
Synchronized block Example public class SyncBlockStringLock {
private Map<String, Object> locks = new HashMap<>();
private static final File rootFolder = new File("d:\\test");
static {
if (!rootFolder.exists()) {
rootFolder.mkdir();
}
}
public static void main (String[] args) {
SyncBlockStringLock obj = new SyncBlockStringLock();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
String path = rootFolder.getAbsolutePath() + File.separatorChar + i;
obj.writeData(path, " thread1 data " + i);
obj.readData(path);
}
});
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
String path = rootFolder.getAbsolutePath() + File.separatorChar + i;
obj.writeData(path, " thread2 data " + i);
obj.readData(path);
}
});
thread1.start();
thread2.start();
}
private void writeData (String path, String data) {
synchronized (getLock(path)) {
try {
Files.write(Paths.get(path), data.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
private void readData (String path) {
synchronized (getLock(path)) {
String s = null;
try {
s = new String(Files.readAllBytes(Paths.get(path)));
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(s);
}
}
private Object getLock (String path) {
if (!locks.containsKey(path)) {
locks.put(path, new Object());
}
return locks.get(path);
}
}
DeadLock Example import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class DeadLockDemo {
public static void main (String[] args) throws InterruptedException {
List<Integer> list1 = new ArrayList<>(Arrays.asList(2, 4, 6, 8, 10));
List<Integer> list2 = new ArrayList<>(Arrays.asList(1, 3, 7, 9, 11));
Thread thread1 = new Thread(() -> {
moveListItem(list1, list2, 2);
});
Thread thread2 = new Thread(() -> {
moveListItem(list2, list1, 9);
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(list1);
System.out.println(list2);
}
private static void moveListItem (List<Integer> from, List<Integer> to, Integer item) {
log("attempting lock for list", from);
synchronized (from) {
log("lock acquired for list", from);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
log("attempting lock for list ", to);
synchronized (to) {
log("lock acquired for list", to);
if(from.remove(item)) {
to.add(item);
}
log("moved item to list ", to);
}
}
}
private static void log (String msg, Object target) {
System.out.println(Thread.currentThread().getName() +
": " + msg + " " +
System.identityHashCode(target));
}
}
DeadLock Fix Example import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class DeadLockFixDemo {
public static void main (String[] args) throws InterruptedException {
List<Integer> list1 = new ArrayList<>(Arrays.asList(2, 4, 6, 8, 10));
List<Integer> list2 = new ArrayList<>(Arrays.asList(1, 3, 7, 9, 11));
Thread thread1 = new Thread(() -> {
moveListItem(list1, list2, 2);
});
Thread thread2 = new Thread(() -> {
moveListItem(list2, list1, 9);
});
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println(list1);
System.out.println(list2);
}
private static void moveListItem (List<Integer> from, List<Integer> to, Integer item) {
log("attempting lock for list", from);
boolean removedSuccessful = false;
synchronized (from) {
log("lock acquired for list", from);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
removedSuccessful = from.remove(item);
}
if (removedSuccessful) {
log("attempting lock for list ", to);
synchronized (to) {
log("lock acquired for list", to);
to.add(item);
log("moved item to list ", to);
}
}
}
private static void log (String msg, Object target) {
System.out.println(Thread.currentThread()
.getName() +
": " + msg + " " +
System.identityHashCode(target));
}
}
wait and notify example public class SimpleWaitNotifyDemo {
private static String message;
public static void main (String[] args) {
Object lock = new Object();
Thread thread1 = new Thread(() -> {
synchronized (lock) {
while (message == null) {
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(message);
});
Thread thread2 = new Thread(() -> {
synchronized (lock) {
message = "A message from thread1";
lock.notify();
}
});
thread1.start();
thread2.start();
}
}
wait and notify example public class WaitNotifyDemo {
public static void main (String[] args) {
SharedObject obj = new SharedObject();
Thread thread1 = new Thread(() -> {
obj.printMessage();
});
Thread thread2 = new Thread(() -> {
obj.setMessage("A message from thread1");
});
thread1.start();
thread2.start();
}
private static class SharedObject {
private String message;
public synchronized void setMessage (String message) {
this.message = message;
notify();
}
public synchronized void printMessage () {
while (message == null) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(message);
}
}
}
|
|
