多线程(一) 多线程介绍及基本使用

<一>多线程介绍

  程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
  进程(process)是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。
  如：运行中的QQ，运行中的MP3播放器。
  程序是静态的，进程是动态的。
  线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
  若一个程序可同一时间执行多个线程，就是支持多线程的。

多线程程序的优点：
  提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
  提高计算机系统CPU的利用率。
  改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

<二>创建线程的四种方式

方式一：
①声明一个类继承 Thread 类
②重写 run() 方法，同时编写线程执行体
③创建该子类的实例
④调用 start() 方法启动线程，默认调用 run() 方法

方式二：
①声明一个类实现 Runnable 接口
②实现 run() 方法，同时编写线程执行体
③创建该实现类的实例
④创建 Thread 类的实例，将实现类的实例作为参数传递给 Thread 的构造器
⑤调用 Thread 的 start() 方法， 启动线程，默认调用 run() 方法

方式三：
class MyThread implements Callable{
@Override
public Integer call() throws Exception{
System.out.println(“come Callable-----”);
return 200;
}
}

public class ThreadDemo1 {
public static void main(String[] args){
FutureTask futureTask = new FutureTask(new MyThread());
new Thread(futureTask).start();
}
}

方式四：线程池
常见线程池：
①newSingleThreadExecutor
  单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行执行任务
②newFixedThreadExecutor(n)
  固定数量的线程池，没提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
③newCacheThreadExecutor（推荐使用）
  可缓存线程池，当线程池大小超过了处理任务所需的线程，那么就会回收部分空闲（一般是60秒无执行）的线程，当有任务来时，又智能的添加新线程来执行。
④newScheduleThreadExecutor
  大小无限制的线程池，支持定时和周期性的执行线程

ExecutorService pool = Executors.常见线程池
例:ExecutorService pool = Executors.newSingleThreadExecutor();

<三>示例
-----实例

public class MyThread implements Runnable{

    @Override
	public void run() {   System.out.println(Thread.currentThread().getName() + "-->执行中。。。");
    }
}

(1) newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

public class TestCachedThreadPool {

    public static void main(String[] args) {
        //创建一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i <= 10; i++) {
            //创建实现了Runnable接口对象
            MyThread myThread = new MyThread();
            //创建 Thread 类的实例，将实现类的实例作为参数传递给 Thread 的构造器
            Thread thread=new Thread(myThread);
            //将线程放入池中进行执行
            pool.execute(thread);
        }
        //关闭线程池
        pool.shutdown();
    }
}

运行结果：
pool-1-thread-1–>执行中。。。
pool-1-thread-5–>执行中。。。
pool-1-thread-4–>执行中。。。
pool-1-thread-3–>执行中。。。
pool-1-thread-2–>执行中。。。
pool-1-thread-7–>执行中。。。
pool-1-thread-6–>执行中。。。
pool-1-thread-8–>执行中。。。
pool-1-thread-2–>执行中。。。
pool-1-thread-6–>执行中。。。
pool-1-thread-8–>执行中。。。

(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

public static void main(String[] args) {
        //创建一个可重用固定线程数的线程池
        ExecutorService pool = Executors.newFixedThreadPool(2);

        for (int i = 0; i <=10 ; i++) {
            MyThread myThread = new MyThread();
            Thread thread = new Thread(myThread);
            pool.execute(thread);
        }

        pool.shutdown();

    }

运行结果：
pool-1-thread-1–>执行中。。。
pool-1-thread-2–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-2–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-2–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-2–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-2–>执行中。。。

(3) newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

public class TestScheduledThreadPool {

    public static void main(String[] args) {

        ScheduledExecutorService schedulePool = Executors.newScheduledThreadPool(2);
        // 5秒后执行任务
        schedulePool.schedule(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+new Date());
            }
        }, 5, TimeUnit.SECONDS);
        // 5秒后执行任务，以后每2秒执行一次
        schedulePool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+new Date());
            }
        }, 5, 2, TimeUnit.SECONDS);
    }

}

注意：定时线程池中某个线程在循环执行的过程中如果发生异常没有处理，则该线程会结束定时。推荐@Scheduled注解

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();

        for (int i = 0; i <=10 ; i++) {
            MyThread myThread = new MyThread();
            Thread thread = new Thread(myThread);
            pool.execute(thread);
        }

        pool.shutdown();
    }

运行结果：
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。
pool-1-thread-1–>执行中。。。