Update 线程状态转换以及基本操作.md

格式修改

Author: dypcoder

2.线程的状态转换以及基本操作/线程状态转换以及基本操作.md

@@ -5,47 +5,45 @@
 1. 通过继承Thread类，重写run方法；
 2. 通过实现runable接口；
 3. 通过实现callable接口这三种方式，下面看具体demo。
-
-		public class CreateThreadDemo {
-		
-		    public static void main(String[] args) {
-		        //1.继承Thread
-		        Thread thread = new Thread() {
-		            @Override
-		            public void run() {
-		                System.out.println("继承Thread");
-		                super.run();
-		            }
-		        };
-		        thread.start();
-		        //2.实现runable接口
-		        Thread thread1 = new Thread(new Runnable() {
-		            @Override
-		            public void run() {
-		                System.out.println("实现runable接口");
-		            }
-		        });
-		        thread1.start();
-		        //3.实现callable接口
-		        ExecutorService service = Executors.newSingleThreadExecutor();
-		        Future<String> future = service.submit(new Callable() {
-		            @Override
-		            public String call() throws Exception {
-		                return "通过实现Callable接口";
-		            }
-		        });
-		        try {
-		            String result = future.get();
-		            System.out.println(result);
-		        } catch (InterruptedException e) {
-		            e.printStackTrace();
-		        } catch (ExecutionException e) {
-		            e.printStackTrace();
-		        }
-		    }
-		
-		}
-		
+```Java
+public class CreateThreadDemo {
+	public static void main(String[] args) {
+        //1.继承Thread
+        Thread thread = new Thread() {
+            @Override
+            public void run() {
+                System.out.println("继承Thread");
+                super.run();
+            }
+        };
+        thread.start();
+        //2.实现runable接口
+        Thread thread1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                System.out.println("实现runable接口");
+            }
+        });
+        thread1.start();
+        //3.实现callable接口
+        ExecutorService service = Executors.newSingleThreadExecutor();
+        Future<String> future = service.submit(new Callable() {
+            @Override
+            public String call() throws Exception {
+                return "通过实现Callable接口";
+            }
+        });
+        try {
+            String result = future.get();
+            System.out.println(result);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+}
+```
 三种新建线程的方式具体看以上注释，需要主要的是：
 
 
@@ -89,9 +87,9 @@ interrupted（）对当前线程进行中断操作，该方法会清除中断标
 
 
 下面结合具体的实例来看一看
-
-	public class InterruptDemo {
-	    public static void main(String[] args) throws InterruptedException {
+```Java
+public class InterruptDemo {
+	public static void main(String[] args) throws InterruptedException {
 	        //sleepThread睡眠1000ms
 	        final Thread sleepThread = new Thread() {
 	            @Override
@@ -120,7 +118,7 @@ interrupted（）对当前线程进行中断操作，该方法会清除中断标
 	        System.out.println("busyThread isInterrupted: " + busyThread.isInterrupted());
 	    }
 	}
-
+```
 输出结果
 > sleepThread isInterrupted: false
 > busyThread isInterrupted: true
@@ -143,7 +141,7 @@ Thread类除了提供join()方法外，另外还提供了超时等待的方法
 	 }
 
 可以看出来当前等待对象threadA会一直阻塞，直到被等待对象threadB结束后即isAlive()返回false的时候才会结束while循环，当threadB退出时会调用notifyAll()方法通知所有的等待线程。下面用一个具体的例子来说说join方法的使用：
-
+```Java
     public class JoinDemo {
        public static void main(String[] args) throws InterruptedException {
         for (int i = 0; i <= 10; i++) {
@@ -171,9 +169,9 @@ Thread类除了提供join()方法外，另外还提供了超时等待的方法
         }
     }
 }
-
+```
 输出结果为：
-
+```
 子线程执行完毕
 主线程执行完毕
 >~~~~~~~~~~~~~~~
@@ -184,6 +182,7 @@ Thread类除了提供join()方法外，另外还提供了超时等待的方法
 主线程执行完毕
 >~~~~~~~~~~~~~~~
 ........
+```
 
 在上面的例子中一个创建了10个线程，每个线程都会等待前一个线程结束才会继续运行。可以通俗的理解成接力，前一个线程将接力棒传给下一个线程，然后又传给下一个线程......