线程的介绍

1、线程、多线程与线程池总结：https://www.jianshu.com/p/b8197dd2934c

2、java中的多线程：http://www.importnew.com/21089.html

一、JAVA 线程实现/创建方式

启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线程，并执行 run()方法。

1、继承 Thread 类

public class MyThread extends Thread { 
    public void run() { 
        System.out.println("MyThread.run()"); 
        } 
} 

MyThread myThread1 = new MyThread(); 
myThread1.start();

2、实现 Runnable 接口

public class MyThread extends OtherClass implements Runnable { 
    public void run() { 
        System.out.println("MyThread.run()"); 
    } 
}   

//启动 MyThread，需要首先实例化一个 Thread，并传入自己的 MyThread 实例：
MyThread myThread = new MyThread(); 
Thread thread = new Thread(myThread); 
thread.start();

也可以使用 lambda 表达式。

3、ExecutorService、Callable<Class>、Future （有返回值线程）

实现 Callable 接口，配置 Future 使用

　　有返回值的任务必须实现 Callable 接口，类似的，无返回值的任务必须 Runnable 接口。执行Callable 任务后，可以获取一个 Future 的对象，在该对象上调用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接口 ExecutorService 就可以实现传说中有返回结果的多线程了。

int taskSize = 5;

//创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);

// 创建多个有返回值的任务
List<Future> list = new ArrayList<Future>(); 
for (int i = 0; i < taskSize; i++) { 
    Callable c = new MyCallable(i + " ");
    
    // 执行任务并获取 Future 对象
    Future f = pool.submit(c); 
    list.add(f); 
} 
// 关闭线程池
pool.shutdown(); 

// 获取所有并发任务的运行结果
for (Future f : list) { 
    // 从 Future 对象上获取任务的返回值，并输出到控制台
    System.out.println("res：" + f.get().toString()); 
}

class MyCallable implements Callable<String> {
        @Override
        public String call() throws Exception {
            return " call() ";
        }
}

4、基于线程池的方式

　　线程和数据库连接这些资源都是非常宝贵的资源。那么每次需要的时候创建，不需要的时候销毁，是非常浪费资源的。那么我们就可以使用缓存的策略，也就是使用线程池。

// 创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(10);
while(true) {
        threadPool.execute(new Runnable() { // 提交多个线程任务，并执行
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running ..");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

Executors提供的四种线程池：https://www.cnblogs.com/yufeng218/p/9941135.html

二、线程的生命周期

　　当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5 种状态。尤其是当线程启动以后，它不可能一直"霸占"着 CPU 独自运行，所以 CPU 需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换。

1、新建状态（NEW）

当程序使用 new 关键字创建了一个线程之后，该线程就处于新建状态，此时仅由 JVM 为其分配内存，并初始化其成员变量的值。

2、就绪状态（RUNNABLE）

当线程对象调用了 start() 方法之后，该线程处于就绪状态。Java 虚拟机会为其创建方法调用栈和程序计数器，等待调度运行。

3、运行状态（RUNNING）

如果处于就绪状态的线程获得了 CPU，开始执行 run()方法的线程执行体，则该线程处于运行状态。

4、阻塞状态（BLOCKED）

　　阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得 cpu timeslice 转到运行(running)状态。
阻塞的情况分三种：

（1）等待阻塞（o.wait->等待对列）：
　　运行(running)的线程执行 o.wait()方法，JVM 会把该线程放入等待队列(waitting queue)中。
（2）同步阻塞(lock->锁池)
　　运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池(lock pool)中。

（3）其他阻塞(sleep/join)

　　运行(running)的线程执行 Thread.sleep(long ms)或 t.join()方法，或者发出了 I/O 请求时，JVM 会把该线程置为阻塞状态。当 sleep()状态超时、join()等待线程终止或者超时、或者 I/O处理完毕时，线程重新转入可运行(runnable)状态。

5、线程死亡（DEAD）

线程会以下面四种方式结束，结束后就是死亡状态。

（1）正常结束：run()或 call()方法执行完成，线程正常结束。

（2）异常结束：线程抛出一个未捕获的 Exception 或 Error。

（3）调用 stop：直接调用该线程的 stop()方法来结束该线程—该方法通常容易导致死锁，不推荐使用。

（4）调用 interrupt ：调用该线程的 interrupt() 方法和 isInterrupted() 方法，优雅的中断线程；

　　a. 线程处于阻塞状态：当调用线程的 interrupt() 方法时，会抛出 InterruptException 异常。

　　阻塞中的那个方法抛出这个异常，通过代码捕获该异常，然后 break 跳出循环状态，从而让我们有机会结束这个线程的执行。

　　通常很多人认为只要调用 interrupt 方法线程就会结束，实际上是错的，一定要先捕获 InterruptedException 异常之后通过 break 来跳出循环，才能
常结束 run 方法。

　　 b. 线程未处于阻塞状态：使用 isInterrupted() 判断线程的中断标志来退出循环。当使用interrupt()方法时，中断标志就会置 true，和使用自定义的标志来控制循环是一样的道理。

public class ThreadSafe extends Thread {
        public void run() {
            while (!isInterrupted()){ //非阻塞过程中通过判断中断标志来退出
                try{
                    Thread.sleep(5*1000);//阻塞过程捕获中断异常来退出
                }catch(InterruptedException e){
                    e.printStackTrace();
                    break;//捕获到异常之后，执行 break 跳出循环
                }
            }
        }
    }

三、面试点

1、sleep 与 wait 区别

sleep：

Thread类的方法；
在调用 sleep()方法的过程中，线程不会释放对象锁；
sleep()方法导致了程序暂停执行指定的时间，让出 cpu 该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态；

wait：

Object类的方法；
调用 wait()方法的时候，线程会放弃对象锁；
进入等待此对象的等待锁定池，只有针对此对象调用 notify()/notifyAll()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态；

posted @ 2018-11-10 16:47 风止雨歇阅读(139) 评论(0) 编辑收藏举报

刷新页面返回顶部

风止雨歇