第十章：线程

一、概念（程序,进程,线程）

（一）、程序

1、为解决某种问题，使用计算机语言编写的一系列指令（代码）

2、本章中的程序，特指静态的，安装在硬盘上的代码集合

（二）、进程

1、内存中正在运行的程序

2、是操作系统进行资源分配的最小单位

3、进程的单位时比较大的，当一个进程运行时，其他单位不能执行，所以后来将进程中的多个任务细化为线程，cpu执行单位也从进程转为更小的线程

4、eg：巡行中的QQ

（三）、线程

1、可以进一步细化为线程（早期是没有线程的，早期cpu在执行时是以进程为单位执行的）

2、是一个进程内部最小的执行单元

3、是操作系统进行任务调度的最小单元（具体要做的事情）

4、eg：QQ中的一个聊天窗口

（四）、注意：

（1）一个进程中可以包含多个线程

（2）、一个线程只能隶属于一个进程，线程不能脱离进程存在

（3）、一个进程中至少有一个线程（即主线程），java中的main方法，就是用来启动主线程的

（4）、主线程可以创建并启动其他资源，所有线程共享内存资源

二、创建线程

（一）、单线程：

main方法时用来启动Java主线程的

eg:

public class OneDemo {
    static int time=1;
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("main1:"+i);
        }
        other();
        for (int i = 0; i < 10; i++) {
            System.out.println("main2:"+i);
        }
        other();
        System.out.println("最后的代码");
    }
    public static void other(){
        for (int i = 0; i < 10; i++) {
            System.out.println("other"+time+":"+i);
        }
        time+=1;
    }

（二）、多线程

1、让几件不相关的事情有机会同时进行

2、如何创建线程

方法一：创建线程对象继承Thread（线程）类，重写run()方法，在run()方法中编写需要执行的任务代码

注意：调用时应调用start()方法（调用时run()只是普通的方法调用，并没有启动线程）

//自定义类
public class MyThread extends Thread{
    //run方法是线程执行任务的方法
    //重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("MyThread:"+i);
        }
    }
}
/*
调用时应调用start()方法
调用时run()只是普通的方法调用，并没有启动线程
*/
//测试类
public static void main(String[] args) {
        MyThread myThread=new MyThread();
        //myThread.run();//只是调用方法，没有启动新的线程
        myThread.start();//启动线程，需要由操作系统调度
        for (int i = 0; i < 10000; i++) {
            System.out.println("main:"+i);
        }

    }

方法二：创建一个任务类，继承Runnable接口，重写run()方法

注意：未继承Thread类，不能用start()方法，所以要利用多态

//自定义类
public class MyTask implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("MyTask:"+i);
        }
    }
}
/*
未继承Thread类，不能用start()方法
利用多态：
*/
//测试类
public class Test{
    public static void main(String[] args) {
        MyTask myTask=new MyTask();//创建一个任务对象
        Thread thread=new Thread(myTask);//创建一个线程
        thread.start();//启动线程,执行mytask任务
        for (int i = 0; i < 10000; i++) {
            System.out.println("main:"+i);
        }
    }
}

注：以后第二种类用的多一点

1、一个类能实现多个接口一个类，用了第二种方法后可以继承其他类，避免单继承的局限性

2、多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源

三、Thread类中方法

（一）、Thread类表示线程，提供了很多方法对线程进行控制

（二）、常用方法：

方 法 原 型	说 明
void start()	启动线程
final String getName()	返回线程的名称
final String setName()	设置线程的名称
final void setPriority(int newPriority)	设置线程的优先级
final int getPriority()	返回线程的优先级
final void join()	等待线程终止
static Thread currentThread()	返回对当前正在执行的线程对象的引用
static void sleep(long millis)	让当先正在执行的程序休眠（暂停执行），休眠时间由millis（毫秒）指定

1、常用方法：

run()：表示线程要执行的任务

start()：启动java线程

setName()：给线程赋名

getName() ：返回线程的名称

2、构造方法：

new Thread（Runable runnable）：接收一个任务对象

new Thread（Runable runnable，String name）：接收一个任务对象，并对线程设置名字

注意：线程默认有名字，系统会自动给为赋值的线程赋名

3、获取在任务中当前正在执行的线程名称

//测试类：
public class Test{
    public static void main(String[] args) {
        MyTask myTask=new MyTask();//创建一个任务对象
        Thread thread1=new Thread(myTask,"线程1");//创建一个线程
        thread1.start();
        Thread thread2=new Thread(myTask);
        thread2.setName("线程2");
        thread2.start();
    }
}
//方法类
public class MyTask implements Runnable{

    @Override
    public void run() {
        Thread thread=Thread.currentThread();//获取正在执行的线程的名称
        System.out.println(thread.getName());
    }
}

4、获得线程优先级：

//方法类
public class MyTask implements Runnable{

    @Override
    public void run() {
        Thread thread=Thread.currentThread();//获取正在执行的线程的名称
        System.out.println(thread.getName()+":"+thread.getPriority());

    }
}
//测试类
public class Test{
    public static void main(String[] args) {
        MyTask myTask=new MyTask();//创建一个任务对象
        Thread thread1=new Thread(myTask,"线程1");//创建一个线程
        thread1.setPriority(4);//设置优先级
        thread1.start();
        Thread thread2=new Thread(myTask,"线程2");
        thread2.setPriority(6);
        thread2.start();
        Thread thread3=new Thread(myTask,"线程3");
        thread3.start();
    }
}

5、sleep(long millis)：暂停执行指定时间（单位毫秒）

//方法类
public class MyTask implements Runnable{

    @Override
    public void run() {
        Thread thread=Thread.currentThread();//获取正在执行的线程的名称
        if (thread.getName().equals("线程1")){
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(thread.getName()+":"+thread.getPriority());

    }
}
//测试类
public class Test{
    public static void main(String[] args) {
        MyTask myTask=new MyTask();//创建一个任务对象
        Thread thread1=new Thread(myTask,"线程1");//创建一个线程
        thread1.setPriority(4);//设置优先级
        Thread thread2=new Thread(myTask,"线程2");
        thread2.setPriority(6);
        Thread thread3=new Thread(myTask,"线程3");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

6、join() ：等待当前线程终止后再执行

四、线程状态

线程生命周期：

新建 new Thread()

就绪

运行：运行中的线程可以被切换，回到就绪状态，也可能因为休眠

阻塞：遇到sleep()，join()进入阻塞状态，操作系统不会调度阻塞状态的线程（阻塞状态结束后会恢复到就绪状态）

死亡：执行任务结束

注：守护线程（使用需要提前设置）：

//方法类
public class MyTask implements Runnable{

    @Override
    public void run() {
        while (true){
            System.out.println("守护线程");
        }
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        MyTask myTask=new MyTask();
        Thread thread=new Thread(myTask);
        thread.setDaemon(true);//使用需要提前设置
        thread.start();
        for (int i = 0; i < 10000; i++) {
            System.out.println("main"+i);
        }
    }
}

五、多线程的概念

1、在一个应用程序中可以存在多个线程，不同的线程可以并行的执行任务

2、优点

（1）、提高程序处理能力

（2）、提高CPU的利用率

（3）、 改善程序结构,将复杂任务分为多个线程,独立运行

3、缺点

（1）、线程也是程序，需要占用内存资源和cpu资源（提升硬件设备）

（2）、多线程需要协调和管理，所以需要跟踪管理线程,使得cpu开销变大

（3）、多个线程对同一个共享资源访问，会出现线程安全问题