diff --git a/03concurrency/0301/pom.xml b/03concurrency/0301/pom.xml new file mode 100644 index 00000000..55691a2d --- /dev/null +++ b/03concurrency/0301/pom.xml @@ -0,0 +1,24 @@ + + + 4.0.0 + + java0.03concurrency + 0301 + 1.0 + + + + org.apache.maven.plugins + maven-compiler-plugin + + 8 + 8 + + + + + + + \ No newline at end of file diff --git a/03concurrency/0301/src/main/java/java0/conc0301/DaemonThread.java b/03concurrency/0301/src/main/java/java0/conc0301/DaemonThread.java new file mode 100644 index 00000000..8d985a55 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/DaemonThread.java @@ -0,0 +1,25 @@ +package java0.conc0301; + +public class DaemonThread { + + public static void main(String[] args) { + Runnable task = new Runnable() { + @Override + public void run() { + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + Thread t = Thread.currentThread(); + System.out.println("当前线程:" + t.getName()); + } + }; + Thread thread = new Thread(task); + thread.setName("test-thread-1"); + thread.setDaemon(true); + thread.start(); + } + + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/Runner1.java b/03concurrency/0301/src/main/java/java0/conc0301/Runner1.java new file mode 100644 index 00000000..1e6657bf --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/Runner1.java @@ -0,0 +1,11 @@ +package java0.conc0301; + +public class Runner1 implements Runnable { + + @Override + public void run() { + for (int i = 0; i < 100; i++) { + System.out.println("进入Runner1运行状态——————————" + i); + } + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/Runner2.java b/03concurrency/0301/src/main/java/java0/conc0301/Runner2.java new file mode 100644 index 00000000..c9ff3b96 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/Runner2.java @@ -0,0 +1,21 @@ +package java0.conc0301; + +public class Runner2 implements Runnable { + + @Override + public void run() { + for (int i = 0; i < 100; i++) { + System.out.println("进入Runner2运行状态——————————" + i); + } + + boolean result = Thread.currentThread().isInterrupted(); + + boolean result1 = Thread.interrupted(); // 重置状态 + + boolean result3 = Thread.currentThread().isInterrupted(); + + System.out.println("Runner2.run result ===>" + result); + System.out.println("Runner2.run result1 ===>" + result1); + System.out.println("Runner2.run result3 ===>" + result3); + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/RunnerMain.java b/03concurrency/0301/src/main/java/java0/conc0301/RunnerMain.java new file mode 100644 index 00000000..4526412e --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/RunnerMain.java @@ -0,0 +1,25 @@ + +package java0.conc0301; + +public class RunnerMain { + + public static void main(String[] args) { + + Runner1 runner1 = new Runner1(); + Thread thread1 = new Thread(runner1); + + Runner2 runner2 = new Runner2(); + Thread thread2 = new Thread(runner2); + + thread1.start(); + thread2.start(); + + thread2.interrupt(); + + System.out.println(Thread.activeCount()); + +// Thread.currentThread().getThreadGroup().list(); +// System.out.println(Thread.currentThread().getThreadGroup().getParent().activeGroupCount()); +// Thread.currentThread().getThreadGroup().getParent().list(); + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/ThreadA.java b/03concurrency/0301/src/main/java/java0/conc0301/ThreadA.java new file mode 100644 index 00000000..50e548f6 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/ThreadA.java @@ -0,0 +1,14 @@ +package java0.conc0301; + +public class ThreadA extends Thread { + + public void run() { + super.run(); + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("这是线程A"); + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/ThreadB.java b/03concurrency/0301/src/main/java/java0/conc0301/ThreadB.java new file mode 100644 index 00000000..0b0ad326 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/ThreadB.java @@ -0,0 +1,26 @@ +package java0.conc0301; + +public class ThreadB implements Runnable { + + @Override + public void run() { + try { + Thread.sleep(500); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("这是线程B"); + + Thread currentThread = Thread.currentThread(); + String currentThreadName = currentThread.getName(); + + System.out.println("这是线程的名称：" + currentThreadName); + System.out.println("返回当前线程" + currentThreadName + "的线程组中活动线程的数量:" + Thread.activeCount()); + System.out.println("返回该线程" + currentThreadName + "的标识符:" + currentThread.getId()); + System.out.println("返回该线程" + currentThreadName + "的优先级:" + currentThread.getPriority()); + System.out.println("返回该线程" + currentThreadName + "的状态:" + currentThread.getState()); + System.out.println("返回该线程" + currentThreadName + "所属的线程组:" + currentThread.getThreadGroup()); + System.out.println("测试该线程" + currentThreadName + "是否处于活跃状态:" + currentThread.isAlive()); + System.out.println("测试该线程" + currentThreadName + "是否为守护线程:" + currentThread.isDaemon()); + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/ThreadC.java b/03concurrency/0301/src/main/java/java0/conc0301/ThreadC.java new file mode 100644 index 00000000..cc01e3b8 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/ThreadC.java @@ -0,0 +1,16 @@ +package java0.conc0301; + +import java.util.concurrent.Callable; + +public class ThreadC implements Callable { + + @Override + public String call() throws Exception { + Thread.sleep(500); + System.out.println("这是线程C"); + return "线程C"; + } + + + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/ThreadMain.java b/03concurrency/0301/src/main/java/java0/conc0301/ThreadMain.java new file mode 100644 index 00000000..3a12ddb7 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/ThreadMain.java @@ -0,0 +1,32 @@ +package java0.conc0301; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.FutureTask; + +public class ThreadMain { + + public static void main(String[] args) { + + ThreadA threadA = new ThreadA(); + threadA.start(); + System.out.println("这是主线程："); + + ThreadB threadB = new ThreadB(); + new Thread(threadB).start(); + System.out.println("这是主线程："); + + ThreadC threadC = new ThreadC(); + FutureTask futureTask = new FutureTask<>(threadC); + new Thread(futureTask).start(); + System.out.println("这是主线程:begin!"); + try { + System.out.println("得到的返回结果是:" + futureTask.get()); + } catch (InterruptedException e) { + e.printStackTrace(); + } catch (ExecutionException e) { + e.printStackTrace(); + } + + } + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/ThreadMain2.java b/03concurrency/0301/src/main/java/java0/conc0301/ThreadMain2.java new file mode 100644 index 00000000..b365b40c --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/ThreadMain2.java @@ -0,0 +1,39 @@ +package java0.conc0301; + +public class ThreadMain2 { + + public static void main(String[] args) { + + ThreadB threadB = new ThreadB(); + for (int i = 0; i < 5; i++) { + new Thread(threadB, "线程名称：（" + i + "）").start(); + } + + try { + Thread.sleep(10000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + //返回对当前正在执行的线程对象的引用 + Thread threadMain = Thread.currentThread(); + System.out.println("这是主线程："); + System.out.println("返回当前线程组中活动线程的数目：" + Thread.activeCount()); + System.out.println("主线程的名称：" + threadMain.getName()); + System.out.println("返回该线程的标识符：" + threadMain.getId()); + System.out.println("返回线程的优先级：" + threadMain.getPriority()); + System.out.println("返回线程的状态：" + threadMain.getState()); + System.out.println("返回该线程所属的线程组：" + threadMain.getThreadGroup()); + System.out.println("测试线程是否为守护线程：" + threadMain.isDaemon()); + + +// try { +// Thread.sleep(10000); +// } catch (InterruptedException e) { +// e.printStackTrace(); +// } + + } + + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/op/Join.java b/03concurrency/0301/src/main/java/java0/conc0301/op/Join.java new file mode 100644 index 00000000..13fadb19 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/op/Join.java @@ -0,0 +1,50 @@ +package java0.conc0301.op; + +public class Join { + + public static void main(String[] args) { + Object oo = new Object(); + + MyThread thread1 = new MyThread("thread1 -- "); + thread1.setOo(oo); + thread1.start(); + + synchronized (oo) { + for (int i = 0; i < 100; i++) { + if (i == 20) { + try { + thread1.join(); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + System.out.println(Thread.currentThread().getName() + " -- " + i); + } + } + } + +} + +class MyThread extends Thread { + + private String name; + private Object oo; + + public void setOo(Object oo) { + this.oo = oo; + } + + public MyThread(String name) { + this.name = name; + } + + @Override + public void run() { + synchronized (oo) { + for (int i = 0; i < 100; i++) { + System.out.println(name + i); + } + } + } + +} \ No newline at end of file diff --git a/03concurrency/0301/src/main/java/java0/conc0301/op/WaitAndNotify.java b/03concurrency/0301/src/main/java/java0/conc0301/op/WaitAndNotify.java new file mode 100644 index 00000000..bd3e1e4e --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/op/WaitAndNotify.java @@ -0,0 +1,73 @@ +package java0.conc0301.op; + +public class WaitAndNotify { + public static void main(String[] args) { + MethodClass methodClass = new MethodClass(); + Thread t1 = new Thread(() -> { + try { + methodClass.product(); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + }, "t1"); + Thread t2 = new Thread(() -> { + try { + methodClass.customer(); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + }, "t2"); + Thread t3 = new Thread(() -> { + try { + methodClass.customer(); + } catch (InterruptedException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + }, "t3"); + t1.start(); + t2.start(); + t3.start(); + + } +} + +class MethodClass { + // 定义生产最大量 + private final int MAX_COUNT = 20; + + int productCount = 0; + + public synchronized void product() throws InterruptedException { + while (true) { + System.out.println(Thread.currentThread().getName() + ":::run:::" + productCount); + Thread.sleep(10); + if (productCount >= MAX_COUNT) { + System.out.println("货舱已满,,.不必再生产"); + + wait(); + }else { + productCount++; + } + + notifyAll(); + } + } + + public synchronized void customer() throws InterruptedException { + while (true) { + System.out.println(Thread.currentThread().getName() + ":::run:::" + productCount); + Thread.sleep(10); + if (productCount <= 0) { + System.out.println("货舱已无货...无法消费"); + wait(); + }else { + productCount--; + } + + notifyAll(); + } + } +} \ No newline at end of file diff --git a/03concurrency/0301/src/main/java/java0/conc0301/sync/Counter.java b/03concurrency/0301/src/main/java/java0/conc0301/sync/Counter.java new file mode 100644 index 00000000..a066caf8 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/sync/Counter.java @@ -0,0 +1,44 @@ +package java0.conc0301.sync; + +public class Counter { + private int sum = 0; + public void incr() { + sum++; + } + public int getSum() { + return sum; + } + + public static void main(String[] args) throws InterruptedException { + int loop = 10000; + + // test single thread + Counter counter = new Counter(); + for (int i = 0; i < loop; i++) { + counter.incr(); + } + System.out.println("single thread: " + counter.getSum()); + + // test multiple threads + final Counter counter2 = new Counter(); + Thread t1 = new Thread(() -> { + for (int i = 0; i < loop / 2; i++) { + counter2.incr(); + } + }); + Thread t2 = new Thread(() -> { + for (int i = 0; i < loop / 2; i++) { + counter2.incr(); + } + }); + t1.start(); + t2.start(); + //Thread.sleep(300); + while (Thread.activeCount()>2){//当前线程的线程组中的数量>2 + Thread.yield(); + } + System.out.println("multiple threads: " + counter2.getSum()); + + + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread1.java b/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread1.java new file mode 100644 index 00000000..4dc7513f --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread1.java @@ -0,0 +1,22 @@ + +package java0.conc0301.sync; + +public class Thread1 implements Runnable { + + @Override + public void run() { + synchronized (this) { + for (int i = 0; i < 10; i++) { + System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); + } + } + } + + public static void main(String[] args) { + Thread1 t1 = new Thread1(); + Thread ta = new Thread(t1, "A"); + Thread tb = new Thread(t1, "B"); + ta.start(); + tb.start(); + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread2.java b/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread2.java new file mode 100644 index 00000000..d0f0638b --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread2.java @@ -0,0 +1,46 @@ + +package java0.conc0301.sync; + +public class Thread2 { + + public void m4t1() { + synchronized (this) { + int i = 5; + while (i-- > 0) { + System.out.println(Thread.currentThread().getName() + " : " + i); + try { + Thread.sleep(500); + } catch (InterruptedException ie) { + } + } + } + } + + public synchronized void m4t2() { + int i = 5; + while (i-- > 0) { + System.out.println(Thread.currentThread().getName() + " : " + i); + try { + Thread.sleep(500); + } catch (InterruptedException ie) { + } + } + } + + public static void main(String[] args) { + final Thread2 myt2 = new Thread2(); + Thread t1 = new Thread(new Runnable() { + public void run() { + myt2.m4t1(); + } + }, "t1"); + Thread t2 = new Thread(new Runnable() { + public void run() { + myt2.m4t2(); + } + }, "t2"); + t2.start(); + t1.start(); + } + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread3.java b/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread3.java new file mode 100644 index 00000000..f9d5d742 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/sync/Thread3.java @@ -0,0 +1,55 @@ + +package java0.conc0301.sync; + +public class Thread3 { + class Inner { + private void m4t1() { + int i = 5; + while (i-- > 0) { + System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i); + try { + Thread.sleep(500); + } catch (InterruptedException ie) { + } + } + } + + private void m4t2() { + int i = 5; + while (i-- > 0) { + System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i); + try { + Thread.sleep(500); + } catch (InterruptedException ie) { + } + } + } + } + + private void m4t1(Inner inner) { + synchronized (inner) { //使用对象锁 + inner.m4t1(); + } + } + + private void m4t2(Inner inner) { + inner.m4t2(); + } + + public static void main(String[] args) { + final Thread3 myt3 = new Thread3(); + final Inner inner = myt3.new Inner(); + Thread t1 = new Thread(new Runnable() { + public void run() { + myt3.m4t1(inner); + } + }, "t1"); + Thread t2 = new Thread(new Runnable() { + public void run() { + myt3.m4t2(inner); + } + }, "t2"); + t1.start(); + t2.start(); + } +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/threadpool/ExecutorServiceDemo.java b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/ExecutorServiceDemo.java new file mode 100644 index 00000000..cc777c9a --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/ExecutorServiceDemo.java @@ -0,0 +1,26 @@ + +package java0.conc0301.threadpool; + +import java.util.concurrent.Callable; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; + +public class ExecutorServiceDemo { + + public static void main(String[] args) { + ScheduledExecutorService executorService = Executors.newScheduledThreadPool(16); + try { + String str = executorService.submit(new Callable() { + @Override + public String call() throws Exception { + return "I am a task, which submited by the so called laoda, and run by those anonymous workers"; + } + }).get(); + + System.out.println("str=" + str); + } catch (Exception e) { + e.printStackTrace(); + } + } + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewCachedThreadPoolDemo.java b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewCachedThreadPoolDemo.java new file mode 100644 index 00000000..69cb8a6e --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewCachedThreadPoolDemo.java @@ -0,0 +1,35 @@ + +package java0.conc0301.threadpool; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class NewCachedThreadPoolDemo { + + public static void main(String[] args) { + + ExecutorService executorService = Executors.newCachedThreadPool(); + + for (int i = 0; i < 10000; i++) { + final int no = i; + Runnable runnable = new Runnable() { + @Override + public void run() { + try { + System.out.println("start:" + no); + Thread.sleep(1000L); + System.out.println("end:" + no); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }; + executorService.execute(runnable); + } + executorService.shutdown(); + System.out.println("Main Thread End!"); + + + } + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewFixedThreadExecutorDemo.java b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewFixedThreadExecutorDemo.java new file mode 100644 index 00000000..19bc39bc --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewFixedThreadExecutorDemo.java @@ -0,0 +1,27 @@ + +package java0.conc0301.threadpool; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class NewFixedThreadExecutorDemo { + + public static void main(String[] args) { + ExecutorService executorService = Executors.newFixedThreadPool(16); + for (int i = 0; i < 100; i++) { + final int no = i; + executorService.execute(() -> { + try { + System.out.println("start:" + no); + Thread.sleep(1000L); + System.out.println("end:" + no); + } catch (InterruptedException e) { + e.printStackTrace(); + } + }); + } + executorService.shutdown(); + System.out.println("Main Thread End!"); + } + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewScheduledThreadExecutorDemo.java b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewScheduledThreadExecutorDemo.java new file mode 100644 index 00000000..9186d21b --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewScheduledThreadExecutorDemo.java @@ -0,0 +1,37 @@ + +package java0.conc0301.threadpool; + +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; + +public class NewScheduledThreadExecutorDemo { + + public static void main(String[] args) { + + ScheduledExecutorService executorService = Executors.newScheduledThreadPool(16); + + for (int i = 0; i < 100; i++) { + final int no = i; + Runnable runnable = new Runnable() { + @Override + public void run() { + try { + System.out.println("start:" + no); + Thread.sleep(1000L); + System.out.println("end:" + no); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + }; + // 10s后执行 + executorService.schedule(runnable, 10, TimeUnit.SECONDS); + } + executorService.shutdown(); + System.out.println("Main Thread End!"); + + + } + +} diff --git a/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewSingleThreadExecutorDemo.java b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewSingleThreadExecutorDemo.java new file mode 100644 index 00000000..e328ca83 --- /dev/null +++ b/03concurrency/0301/src/main/java/java0/conc0301/threadpool/NewSingleThreadExecutorDemo.java @@ -0,0 +1,29 @@ + +package java0.conc0301.threadpool; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class NewSingleThreadExecutorDemo { + + public static void main(String[] args) { + + ExecutorService executorService = Executors.newSingleThreadExecutor(); + + for (int i = 0; i < 10; i++) { + final int no = i; + executorService.execute(() -> { + System.out.println("start:" + no); + try { + Thread.sleep(1000L); + } catch (InterruptedException e) { + e.printStackTrace(); + } + System.out.println("end:" + no); + }); + } + executorService.shutdown(); + System.out.println("Main Thread End!"); + } + +}