多线程笔记

多线程

1、概述

1.1、线程与进程

• 进程
  • 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间
• 线程
  • 线程是进程的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程至少有一个线程。
  • 线程实际上是在进程基础之上的进一步划分，一个进程启动后，里面的多个执行路径又可以划分为若干个线程。

1.2、线程调度

• 分时调度
  • 所有的线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间
• 抢占式调度
  • 优先让优先级高的线程使用cpu，如果线程的优先级相同，那么会随机选择一个（线程随机性），java使用的为抢占式调度。
  • cpu使用抢占式调度模式在多个线程之间进行着高速的切换。对于cpu的一个核心而言，某个时刻，只能执行一个线程，而cpu在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序的运行效率，让cpu的使用率更高。

1.3、同步与异步

• 同步
  • 排队执行，效率低但是安全
• 异步
  • 同时执行，效率高但是数据不安全

1.4、并发于并行

• 并发
  • 指两个或多个事件在同一时间段内发生。
• 并行
  • 指两个或多个事件在同一时刻发生（同时发生）。

2、线程创建

2.1、继承Thread类，重写run方法

public class ThreadTest01 extends Thread{

    public void run(){
        //编写自己的线程代码
        System.out.println(Thread.currentThread().getName());
    }
    public static void main(String[] args){ 
        ThreadTest01 thread = new ThreadTest01(); 
        ThreadTest01.setName("我是测试线程1");
        ThreadTest01.start();       
        System.out.println(Thread.currentThread().toString());  
    }
}

2.2、实现Runable接口，重写run方法

public class ThreadTest02 {
 
    public static void main(String[] args){ 
        System.out.println(Thread.currentThread().getName());
        Thread t1 = new Thread(new MyThread());
        t1.start(); 
    }
}
 
class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"我是通过实现接口的线程实现方式！");
    }   
}

2.3、通过Callable和FutureTask创建线程

a、创建Callable接口的实现类，并实现call方法

b、创建Callable实现类的实现，使用FutureTask类包装Callable对象，该FutureTask对象封装了Callable对象的Call方法的返回值

c、使用FutureTask对象作为Thread对象的target创建并启动线程

d、调用FutureTask对象的get()来获取子线程执行结束的返回值

public class ThreadTest03 {
 
    public static void main(String[] args) { 
        Callable<Object> callable = new Tickets<Object>();
        FutureTask<Object> task = new FutureTask<Object>(callable);
 
        Thred t = new Thread(task);
 
        System.out.println(Thread.currentThread().getName());
 
        t.start();
 
    }
 
}
 
class Tickets<Object> implements Callable<Object>{
 
    //重写call方法
    @Override
    public Object call() throws Exception {
        System.out.println(Thread.currentThread().getName()+"-->我是通过实现Callable接口通过FutureTask包装器来实现的线程");
        return null;
    }   
}

2.4、通过线程池创建线程

public class ThreadTest05{
 
    private static int POOL_NUM = 10;     //线程池数量
 
    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        ExecutorService executorService = Executors.newFixedThreadPool(5);  
        for(int i = 0; i<POOL_NUM; i++)  
        {  
            RunnableThread thread = new RunnableThread();
 
            //Thread.sleep(1000);
            executorService.execute(thread);  
        }
        //关闭线程池
        executorService.shutdown(); 
    }   
 
}
 
class RunnableThread implements Runnable  
{     
    @Override
    public void run()  
    {  
        System.out.println("通过线程池方式创建的线程：" + Thread.currentThread().getName() + " ");  
 
    }  
}  

3、Runable与Callable

3.1、接口定义

//Callable接口
public interface Callable<V> {
    V call() throws Exception;
} //Runnable接口
public interface Runnable {
    public abstract void run();
}

3.2、Callable使用步骤

1. 编写类实现Callable接口 , 实现call方法 
  class XXX implements Callable<T> {
            @Override
            public <T> call() throws Exception {
              return T; 
            }
  }
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
       FutureTask<Integer> future = new FutureTask<>(callable); 
3. 通过Thread,启动线程
        new Thread(future).start();

3.3、Runnable与Callable的相同点

• 都是接口
• 都可以编写多线程程序
• 都采用Thread.start()启动线程

3.3、Runnable与Callable的不同点

• Runnable没有返回值；Callable可以返回执行结果
• Callable接口的call()允许抛出异常；Runnable的run()不能抛

3.4、Callable获取返回值

Callable接口支持返回执行结果，需要调用FutureTask.get()得到，此方法会阻塞主进程的继续往下执行，如果不调用不会阻塞。

4、线程池

如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程 就会大大降低 系统的效率，因为频繁创建线程和销毁线程需要时间. 线程池就是一个容纳多个线程的容 器，池中的线程可以反复使用，省去了频繁创建线程对象的操作，节省了大量的时间和资源。

4.1、线程池的好处

• 降低资源消耗
• 提高响应速度
• 提高线程的可管理性

4.2、Java中的四种线程池

4.2.1、缓存线程池

/**
缓存线程池. (长度无限制) 执行流程:
1. 判断线程池是否存在空闲线程
2. 存在则使用
3. 不存在,则创建线程 并放入线程池, 然后使用
* * * * * * */
ExecutorService service = Executors.newCachedThreadPool(); //向线程池中 加入 新的任务
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});

4.2.2、定长线程池

/**
* 定长线程池.
* (长度是指定的数值) * 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 */
ExecutorService service = Executors.newFixedThreadPool(2);
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});

4.2.3、单线程线程池

效果与定长线程池 创建时传入数值1 效果一致. /**
单线程线程池. 执行流程:
1. 判断线程池 的那个线程 是否空闲
2. 空闲则使用
4. 不空闲,则等待 池中的单个线程空闲后 使用
* * * * * */
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});
service.execute(new Runnable() {
    @Override
    public void run() {
System.out.println("线程的名称:"+Thread.currentThread().getName()); }
});

4.2.4、周期性任务定长线程池

/**
* 周期任务 定长线程池.
* 执行流程:
* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程 *
* 周期性任务执行时:
* 定时执行, 当某个时机触发时, 自动执行某任务 .
*/
public static void main(String[] args) {
  ScheduledExecutorService service = Executors.newScheduledThreadPool(2);
/**
* 定时执行 
* 参数1. runnable类型的任务
* 参数2. 时长数字
* 参数3. 时长数字的单位
*/
  
/*service.schedule(new Runnable() {
    @Override
    public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿"); }
},5,TimeUnit.SECONDS);
*/
/**
* 周期执行
* 参数1. runnable类型的任务
* 参数2. 时长数字(延迟执行的时长)
* 参数3. 周期时长(每次执行的间隔时间)
* 参数4. 时长数字的单位
*/  
    service.scheduleAtFixedRate(new Runnable() {
      
        @Override
        public void run() {
System.out.println("俩人相视一笑~ 嘿嘿嘿"); }
    },5,2,TimeUnit.SECONDS);
}

5、synchronized关键字

• 修饰代码块
• 修饰方法
• 修饰静态方法
• 修饰类

无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。

每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。

6、多线程生命周期

6.1、NEW（新建状态）

• 新创建了一个线程对象。

6.2、RUNNABLE（可运行状态）

• 线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

6.3、RUNNING（可运行状态）

• 可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

6.4、BLOCKED(阻塞状态)

• 阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。
  • 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。
  • 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。
  • 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

6.5、DEAD（死亡状态）

• 线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生

6.6、线程改变状态常用方法

1、Thread.sleep(long millis):一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。

2、Thread.yield():一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。

3、t.join()/t.join(long millis):当前线程里调用其它线程1的join方法，当前线程阻塞，但不释放对象锁，直到线程1执行完毕或者millis时间到，当前线程进入可运行状态。

4、obj.wait():当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。

5、obj.notify():唤醒在此对象监视器上等待的单个线程，选择是任意性的

6、notifyAll():唤醒在此对象监视器上等待的所有线程。