Java 并发编程实践基础 读书笔记： 第一章 JAVA并发编程实践基础

1.创建线程的方式：

 /**
  * StudySjms
  * <p>
  * Created by haozb on 2018/2/28.
  */
 public class ThreadDemo extends Thread {
     /**
      * 定义线程的名字
      * @param name
      */
     public ThreadDemo(String name) {
         super(name);
     }
 
     @Override
     public void run() {
         for (int i = ; i < ; i++) {
             System.out.println(this.getName()+":"+i);
         }
     }
 
     public static void main(String[] args) {
         for (int i = ; i < ; i++) {
             new ThreadDemo("name"+i).start();
         }
     }
 }

 /**
  * StudySjms
  * <p>
  * Created by haozb on 2018/2/28.
  */
 public class ThreadDemo implements Runnable {
     @Override
     public void run() {
         for (int i = ; i < ; i++) {
             System.out.println(Thread.currentThread().getName()+":"+i);
         }
     }
 
     public static void main(String[] args) {
 /*        Runnable demo = new ThreadDemo();
         for (int i = 0; i < 3; i++) {
             new Thread(demo,""+i).start();
         }*/
 
         // 也可以直接采用内名内部类方式来创建
         final int num = ;
         for (int i = ; i < ; i++) {
             new Thread(new Runnable() {
                 @Override
                 public void run() {
                     for (int i = ; i < num; i++) {
                         System.out.println(Thread.currentThread().getName()+":"+i);
                     }
                 }
             },""+i).start();
         }
     }
 }

Executors其实就是工厂类，用来创建各种的线程池;

 import java.util.concurrent.*;
 
 /**
  * StudySjms
  * <p>
  * Created by haozb on 2018/2/28.
  */
 public class ThreadPool {
     public static void main(String[] args) {
         //ExecutorService pool = Executors.newFixedThreadPool(2);
         // 这种是固定线程数的线程池，控制了现场的最大并发量
         //ExecutorService pool = Executors.newCachedThreadPool();
         // 这种没有长度限制，会自动控制池的大小，如果任务多了，会创建新现场，如果任务少了，会回收线程
         //ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
         /*
         这种例子是延迟3秒执行
         pool.schedule(new Runnable() {
             @Override
             public void run() {
 
             }
         },3,TimeUnit.SECONDS);*/
         /*
         这种是延迟1秒 每3秒执行一次
         pool.scheduleAtFixedRate(new Runnable() {
             @Override
             public void run() {
 
             }
         },1,3,TimeUnit.SECONDS);*/
         /*
         相当于单线程执行任务，有顺序
         ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
         */
 
         ExecutorService pool = new ThreadPoolExecutor(,,0L, TimeUnit.MILLISECONDS,new LinkedBlockingDeque<Runnable>());
         for (int i = ; i < ; i++) {
             final int tmp = i;
             Runnable run = new Runnable() {
                 @Override
                 public void run() {
                     long time = (long)(Math.random()*);
                     System.out.println(Thread.currentThread().getName()+":"+tmp+"sleeping"+time);
 
                     try {
                         Thread.sleep(time);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             };
             pool.execute(run);
         }
         pool.shutdown();
     }
 }

线程的基本控制方法：

Thread.sleep();   使线程睡眠，放弃cpu

join ：使一个线程等待另一个线程完事在执行。eg: t1里面，t2.join()   t1暂停执行，立即执t2,t2执行完事之后再去执行t1

　　可以有参数，t2.join(10);  表示为t1只等t210毫秒就继续执行了

interrupt()：中断线程，有些时候需要在线程执行过程中中断线程。