java多线程

一 什么叫线程？

        那我们要先了解什么叫进程，线程依赖于进程而存在的。
进程：正在运行的程序

是系统进行资源调用和资源分配的独立单位
每一个进程都有它自己的内存空间和系统资源
线程（Thread）：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径就是单线程程序
记事本程序：在调出页面设置的时候只能在关闭页面设置之后进行其他操作，否则无法进行其他操作。

进程(Process)：进程是执行城西的一次执行过程，他叔一个动态的概念。是系统资源分配的单位。

多线程：一个进程如果只有多条执行路径就是多线程程序

注意： 很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个CPU的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

二.多线程的创建

方法一：继承Thread类
Java是通过java.lang.Thread 类来代表线程的。（不需要导包）
按照面向对象的思想，Thread类应该提供了实现多线程的方式。
方法：

定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
为什么要重写run（）方法：

因为在MyThread里面还有其他的代码，并不是所有的代码都需要被线程执行，为了区分哪些被线程执行，java就提供了一个run（）方法

创建MyThread类的对象
调用线程对象的start()方法启动线程（启动后还是执行run方法的）
优缺点：

优点：编码简单

缺点：线程类已经继承Thread，无法继承其他类，不利于扩展。

/**
   目标：多线程的创建方式一：继承Thread类实现。
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        // 3、new一个新线程对象
        Thread t = new MyThread();
        // 4、调用start方法启动线程（执行的还是run方法）
        //run方法就是一个普通的方法，没有真正启动一个线程，就会把run方法执行完毕，才向下执行，
        //就是会先执行run方法 只有当run执行完毕才会执行其他线程
        t.start();
 
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }
 
    }
}
 
/**
   1、定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
       2、重写run方法，里面是定义线程以后要干什么
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

问题：为什么不直接调用了run方法，而是调用start启动线程。

   答：  直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。 只有调用start方法才是启动一个新的线程执行。

方式二：实现Runnable接口

1. 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
2. 创建MyRunnable任务对象
3. 把MyRunnable任务对象交给Thread处理。
4. 调用线程对象的start()方法启动线程

构造器	说明
public Thread(String name)	可以为当前线程指定名称
public Thread(Runnable target)	封装Runnable对象成为线程对象
public Thread(Runnable target ，String name )	封装Runnable对象成为线程对象，并指定线程名称

话不多说，上代码：

/**
   目标：学会线程的创建方式二并理解它的优缺点。
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        // 3、创建一个任务对象
        Runnable target = new MyRunnable();
        // 4、把任务对象交给Thread处理
        Thread t = new Thread(target);
        // Thread t = new Thread(target, "1号");
        // 5、启动线程
        t.start();
 
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }
    }
}
 
/**
   1、定义一个线程任务类 实现Runnable接口
 */
class MyRunnable  implements Runnable {
    /**
       2、重写run方法，定义线程的执行任务的
     */
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

方式三：JDK 5.0新增：实现Callable接口

这个编码有点复杂！小编水平暂且还不到位，请尽请期待小编的蜕变！

三.线程Thread的常用方法

1. 当有很多线程在执行的时候，该怎么去区分这些线程呢？

此时需要使用Thread的常用方法：getName()、setName()、currentThread()等。

Thread常用方法、构造器

方法名称	说明
String getName​()	获取当前线程的名称，默认线程名称是Thread-索引
void setName​(String name)	设置线程名称
public static Thread currentThread()：	返回对当前正在执行的线程对象的引用
public static void sleep(long time)	让线程休眠指定的时间，单位为毫秒。
public void run()	线程任务方法
public void start()	线程启动方法

 
public class MyThread extends Thread{
    public MyThread(){}
    public MyThread(String name){
        super(name);
    }
 
    public void run(){
        for(int i=0;i<50;i++){
            System.out.println(getName()+"追逐xx的速度"+i+"km/h");
        }
    }
}
 
 
 
 
 
 
 
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t=new MyThread("张三");
        Thread t1=new MyThread("李四");
        t.start();
        t1.start();
    }
 
}

 四.线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

思路：提前创建多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

好处：

提高响应速度(减少了创建新线程的时间)
降低资源消耗(重复利用线程池中的资源，不需要每次都构建)
便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
使用线程池

JDK 5.0起提供了线程池相关API：ExecutorService和Executors

ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

void execute(Tunnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
Futuresubmit(Callabletask)：执行任务，有返回值，一般用来执行Callable
void shutdown()：关闭线程池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

2.不使用线程池的问题    

          如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

3.工作原理

 

4.如何得到线程池对象

方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象

ExecutorService-->ThreadPoolExecutor

方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象 

package kwok.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        //1.创建线程池
        //newFixedThreadPool参数为线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);
        //施行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        //2.关闭连接
        service.shutdown();
    }
}
class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

小编有话说：

就写到这了，希望能帮上大家！