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 = 0; i < 20; i++) {
            System.out.println(this.getName()+":"+i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; 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 = 0; i < 5; 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 = 5;
        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; 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(5,100,0L, TimeUnit.MILLISECONDS,new LinkedBlockingDeque<Runnable>());
        for (int i = 0; i < 10; i++) {
            final int tmp = i;
            Runnable run = new Runnable() {
                @Override
                public void run() {
                    long time = (long)(Math.random()*1000);
                    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()：中断线程，有些时候需要在线程执行过程中中断线程。