Java并发：线程核心机制，基础概念扩展

Author: cicadasmile

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread01.java

@@ -0,0 +1,50 @@
+package com.multy.thread.block02extend;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExtendThread01 {
+    public static void main(String[] args) {
+        List<Object> dataList = new ArrayList<>() ;
+        dataList.add("A");
+        dataList.add("B");
+        dataList.add("C");
+        // 把一个大的集合按照每个子集合的2个元素切割
+        List<List<Object>> splitList = splitList(dataList,2);
+        for (List<Object> list:splitList){
+            System.out.println(list);
+        }
+        // 多线程处理
+        for (List<Object> childList:splitList){
+            ListTask listTask = new ListTask(childList) ;
+            Thread runThread = new Thread(listTask);
+            runThread.start();
+        }
+    }
+    /**
+     * List 集合切割
+     */
+    private static List<List<Object>> splitList (List<Object> list, int childSize) {
+        if (list == null || list.size() == 0 || childSize < 1) {
+            return null;
+        }
+        List<List<Object>> result = new ArrayList<>();
+        int size = list.size();
+        int count = (size + childSize - 1) / childSize ;
+        for (int i = 0; i < count; i++) {
+            List<Object> subList = list.subList(i * childSize, ((i + 1) * childSize > size ? size : childSize * (i + 1)));
+            result.add(subList);
+        }
+        return result;
+    }
+}
+class ListTask implements Runnable {
+    private List<Object> list ;
+    public ListTask (List<Object> list){this.list=list;}
+    @Override
+    public void run() {
+        for (Object object:list){
+            System.out.println(Thread.currentThread().getName()+"=="+object);
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread02.java

@@ -0,0 +1,31 @@
+package com.multy.thread.block02extend;
+
+public class ExtendThread02 {
+    public static void main(String[] args) {
+        StopThread stopThread = new StopThread() ;
+        stopThread.start();
+        // 标记当前线程停止信号，且抛出中断异常，但没有停止
+        stopThread.interrupt();
+        // 判断当前线程是否已经是终止状态
+        System.out.println("1=="+stopThread.isInterrupted());
+        // 清除当前线程的终止信号,并判断执行该方法的线程(main)是否中断
+        System.out.println("2=="+stopThread.interrupted());
+        // 再次判断当前线程状态
+        System.out.println("3=="+stopThread.isInterrupted());
+        System.out.println("main end ...");
+    }
+}
+class StopThread extends Thread {
+    @Override
+    public void run() {
+        for (int i = 0 ; i < 10 ; i++){
+            try {
+                System.out.println(Thread.currentThread().getId()+"="+i);
+                // 线程阻塞1秒
+                Thread.sleep(1000);
+            } catch (InterruptedException e){
+                e.printStackTrace();
+            }
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread03.java

@@ -0,0 +1,30 @@
+package com.multy.thread.block02extend;
+
+public class ExtendThread03 {
+    public static void main(String[] args) {
+        Priority01 priority01 = new Priority01();
+        priority01.start();
+        System.out.println("priority01="+priority01.getPriority());
+        Priority02 priority02 = new Priority02();
+        priority02.start();
+        System.out.println("priority02="+priority02.getPriority());
+        priority01.setPriority(10);
+        priority02.setPriority(1);
+    }
+}
+class Priority01 extends Thread {
+    @Override
+    public void run() {
+        for (int i = 0 ; i < 100 ; i++){
+            System.out.println(Thread.currentThread().getName()+";i="+i);
+        }
+    }
+}
+class Priority02 extends Thread {
+    @Override
+    public void run() {
+        for (int a = 0 ; a < 100 ; a++){
+            System.out.println(Thread.currentThread().getName()+";a="+a);
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread04.java

@@ -0,0 +1,36 @@
+package com.multy.thread.block02extend;
+
+import java.util.concurrent.TimeUnit;
+
+public class ExtendThread04 {
+    public static void main(String[] args) {
+        JoinThreadA joinThreadA = new JoinThreadA() ;
+        joinThreadA.start();
+    }
+}
+class JoinThreadA extends Thread {
+    @Override
+    public void run() {
+        System.out.println("缺水中...");
+        JoinThreadB joinThreadB = new JoinThreadB() ;
+        joinThreadB.start();
+        try{
+            joinThreadB.join();
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+        System.out.println("喝水中...");
+    }
+}
+class JoinThreadB extends Thread {
+    @Override
+    public void run() {
+        System.out.println("买水中...");
+        try{
+            TimeUnit.SECONDS.sleep(2);
+        } catch (Exception e){
+            e.printStackTrace();
+        }
+        System.out.println("买到水...");
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread05.java

@@ -0,0 +1,18 @@
+package com.multy.thread.block02extend;
+
+import java.util.concurrent.TimeUnit;
+
+public class ExtendThread05 {
+    private static final ThreadLocal<Long> threadLocal = new ThreadLocal<>() ;
+    private static void initBegin (){
+        threadLocal.set(System.currentTimeMillis());
+    }
+    private static Long overTime (){
+        return System.currentTimeMillis()-threadLocal.get();
+    }
+    public static void main(String[] args) throws Exception {
+        ExtendThread05.initBegin();
+        TimeUnit.SECONDS.sleep(3);
+        System.out.println(ExtendThread05.overTime());
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread06.java

@@ -0,0 +1,35 @@
+package com.multy.thread.block02extend;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.util.concurrent.TimeUnit;
+
+public class ExtendThread06 {
+    public static void main(String[] args) throws Exception {
+        InputStreamReader is = new InputStreamReader(System.in);
+        BufferedReader br = new BufferedReader(is);
+        String value = br.readLine();
+        CheckThread checkThread = new CheckThread(value) ;
+        checkThread.setDaemon(true);
+        checkThread.start();
+    }
+}
+class CheckThread extends Thread {
+    private String spell ;
+    public CheckThread (String spell){
+        this.spell = spell ;
+    }
+    @Override
+    public void run() {
+        if (spell.startsWith("cs")){
+            System.out.println(spell+"：输入正确");
+        } else {
+            System.out.println(spell+"：输入错误");
+        }
+        try {
+            TimeUnit.SECONDS.sleep(10);
+        } catch (InterruptedException e){
+            e.printStackTrace();
+        }
+    }
+}

java-se-base-parent/model-multy-thread/src/main/java/com/multy/thread/block02extend/ExtendThread07.java

@@ -0,0 +1,30 @@
+package com.multy.thread.block02extend;
+
+public class ExtendThread07 {
+    public static void main(String[] args) {
+        TryThread tryThread = new TryThread();
+        tryThread.setName("try-name");
+        // 定义运行中异常处理策略
+        MyExe myExe = new MyExe() ;
+        tryThread.setUncaughtExceptionHandler(myExe);
+        tryThread.start();
+    }
+}
+class TryThread extends Thread {
+    @Override
+    public void run() {
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException e){
+            e.printStackTrace();
+        }
+        // 如何处理这里异常？
+        Integer.parseInt("cicada") ;
+    }
+}
+class MyExe implements Thread.UncaughtExceptionHandler {
+    @Override
+    public void uncaughtException(Thread t, Throwable e) {
+        System.out.println(t.getName()+"；异常："+e.getMessage());
+    }
+}