一、线程
1.概念：
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。——————来自百度百科
2.多线程的优点
①提供应用程序的响应，对图形化界面更有意义，可增强用户体验。
②提高计算机CPU的利用率
③改善程序结构。即将长又复杂的进程分为多个线程，独立运行，利于理解和修改。
3.何时需要多线程
①提高应用程序同时执行两个或多个任务。
②程序需要实现一些需要等待的任务时，如用户输入，文件读写操作，网络操作，搜索等。
③需要后台运行的程序时。
比如说我们在运行360的时候，由于360这个应用程序比较大。而且模块也比较多，所以把这个较大的应用程序分为多线程，在后台应用可以看见他们的运行情况以及占了多少CPU等，如图：
在后台可以看见应用程序的运行，也就是说把一个进程分成了多线程进行执行。
4.线程类的特性
java语言的JVM允许运行多个线程，它通过java.lang.Thread类来体现。
①把每个线程都是通过某个特定的Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体。
②通过该Thread对象的start()方法来启动这个线程，而非直接调用。
二、多线程的创建方式
方式一：继承Thread类创建线程
1).d定义Thread类的子类，并重写该类的run()方法，该方法的方法体就是线程需要完成的任务，run()方法也称为线程执行体。
2).创建Thread子类的实例，也就是创建了线程对象
3).启动线程，即调用线程的start()方法
实现代码：以卖票为例
创建一个继承Thread的子类
class MyThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":" + i);
}
}
}
}
测试类，启动通过对象调用start()方法启动线程。
public class ThreadTest {
public static void main(String[] args) {
//3.创建Thead类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start：①启动当前线程 ②调用当前线程run（）
t1.start();
//问题一：不能通过直接调用run（）的方法启动线程
// t1.run();
//问题二：再启动一个线程，遍历100以内的偶数，不可以还让已经start（）的线程去执行，会报异常
//t1.start();
//我们需要创建一个线程对象。
MyThread t2= new MyThread();
t2.start();
//如下操作仍然是在main线程中执行。
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":" + "*************main()**********"+i );
}
}
}
}
Thread中常用的方法
1.start()：启动当前线程，调用当前线程的run()
2.run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中。
3.currentThread():静态方法，返回执行当前代码线程。
4.getName():获取当前线程的名字
5.setName():设置当前线程的名字。
6.yield()：释放当前cpu的执行权.
7.join():在线程A中调用线程B的join（），此时线程A就进入阻塞状态，直到线程B完全执行完以后，线程a才会结束阻塞状态。
8.stop():已过时，当执行此方法时，强制结束当前线程
9.sleep(longmillitime):让当前线程睡眠制定的millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态
10.isAlive():判断当前线程是否存活
方式二：实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现类实现Runnable中的抽象类的方法run（）
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start（）；
实现代码
测试类
public class ThreadTest1 {
public static void main(String[] args) {
MThread mThread=new MThread();
Thread t1=new Thread(mThread);
t1.setName("线程一");
//通过Thread类的对象调用start(); ①启动当前线程 ②调用当前线程的run();
t1.start();
//再启动一个线程，遍历100以内的偶数
Thread t2=new Thread(mThread);
t2.setName("线程二");
t2.start();
}
}
实现Runnable接口
class MThread implements Runnable{
//实现类实现Runnable中的抽象类的方法run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i%2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
方式三：实现Callable接口
1）创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
2）创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
4）调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
实现代码
Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum=0;
for (int i =1; i <= 100; i++) {
if (i%2 == 0) {
System.out.println(i);
sum +=i;
}
}
return sum;
}
}
测试类
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread numThread=new NumThread();
//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FuntureTask对象。
FutureTask futureTask= new FutureTask(numThread);
//5.将FuntureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start();
new Thread(futureTask).start();
try{
//6.获取Callable中call方法的返回值
//get()返回值即为FutureTask构造器参数Callable实现类重写的call()返回值。
Object sum = futureTask.get();
System.out.println("总和为"+sum);
}catch (InterruptedException e){
e.printStackTrace();
}catch (ExecutionException e){
e.printStackTrace();
}
}
}
方式四：使用线程池
*好处：
1）.提高响应速度（减少了创建新线程的时间）
2）.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3）.便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
线程池实现类
class NumberThread implements Runnable{
public void run(){
for (int i = 0; i <100 ; i++) {
if (i %2==0) {
System.out.println(Thread.currentThread().getName()+":"+ i);
}
}
}
}
测试类
public class ThreadPool {
public static void main(String[] args) {
//1.提供制定线程数量的线程池
//Excutors相当于一个工具类。
ExecutorService service= Executors.newFixedThreadPool(10);
ThreadPoolExecutor service1=(ThreadPoolExecutor) service;
//设置线程池的属性
System.out.println(service.getClass());
service1.setCorePoolSize(15);
//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
//service.submit();//适合适用于Callable
//3.关闭连接池
service.shutdown();
}
}
关于Thread与Runnable的详情，可以参考以下文章。
Thread和Runnable的异同