线程

线程概念

• **程序：**一个完整的可以运行的，指令+数据的byte序列，比如QQ.exe
• **进程：**正在运行的程序，是程序动态运行的过程（在内存中运行）
• **线程：**用来完成某个特定的任务目标，比如：收发信息，播放音乐，下载
• **并发：**多个线程同时运行就叫线程并发

操作系统在运行时，会执行多个任务，每个任务都是一个程序，每个运行的程序对应一个进程，一个进程中可能包含多个线程

• 进程是资源分配的最小单位，线程是最小的执行单位
• 一个进程可以有多个线程
• 线程共享进程的资源

创建线程的三种方法：

1.继承Thread类

Thread是Java中表示线程的类，里面包含了一个线程运行的方法ru()

使用Thread创建并启动线程：

• 创建类继承Thread
• 创建线程的实体对象
• 调用线程实例对象的start()方法启动线程

线程类

//1.继承Thread
public class ThreadDemo extends Thread{
 	//重写Run方法
    @Override
    public void run(){
        System.out.println("开始执行run方法");
        for(int i = 0;i<10;i++){
            System.out.println(i);
           	//线程休眠
            try{
                Thread.sleep(1000);//1000毫秒
            }catch(InterruptedException e){
                e.printStackTrance();
            }
        }
    }
}

测试线程

public class Demo{
    public static void main(String[] args){
        //3.创建线程实例对象
        ThreadDemo td = new ThreadDemo();
        //使用start方法启动线程，启动线程后，会自动调用run方法
        td.start();
    }
}

注意：

• 启动线程调用start()方法
• 线程启动后会自动调用run()方法
• 需要线程完成某件事情，将对应的代码添加到run()方法中

2.实现Runable接口（推荐）

步骤：

• 创建类实现Runable接口
• 实现run方法
• 创建runable接口的实现类对象
• 使用thread类创建对象，并将第三步创建对象作为参数传递到构造方法中
• 调用thread类的对象的start方法启动线程

线程类

//1.创建类实现Runnable接口
public class RunnableDemo implements Runnable{
    //2.重写run方法
    @override
    public void run(){
        System.out.println("Runnable线程启动了");
    }
    //3.创建Runnable实现类的对象
    RunnableDemo rd = new RunnableDemo();
    //4.使用runnable实现类对象创建thread对象
    Thread t = new Thread(rd);
    //5.使用thread类对象启动线程
    t.start();
}

3.使用匿名内部类

//直接在需要使用线程的类内部创建匿名内部类
Thread t = new Thread(){
    @override
    public void run(){
        System.out.println("匿名内部类实现线程");
    }
};
t.run();

线程的生命周期

线程的生命周期有五个状态：

• 新建（new）：使用new关键字创建线程实例后，该线程就进入新建状态，此时线程还不会执行
• 就绪（Runnable）：调用了Start（）方法，进入就绪状态，此时线程可以执行，此时等待CPU分配执行资源（时间片）后即可运行
• 运行（Running）：当CPU为该线程分配了资源之后，该线程的run（）方法开始执行，此时线程处于运行状态
• 阻塞（Block）：线程休眠（sleep），等待（wait）或者调用了阻塞IO方法（比如Scanner）时，主动放弃了CPU资源，会进入阻塞状态，线程运行处于停止状态，此时就是阻塞状态
• 死亡（Dead）：当线程run方法执行完毕后，线程就处于死亡状态

注意：

• 当线程创建后不会立即执行，需要调用start（）方法，此时线程处理就绪
• 当线程就绪后，需要分配CPU分配了资源才会执行
• 当线程阻塞时，会让出战友CPU资源，当阻塞结束后，线程会计入到就绪状态，重新等待CPU分配资源，而不是进入运行状态

线程的加入：Thread.join()

代表等待该线程运行终止，原线程才继续运行

该方法可以加参数，线程对象.join(毫秒数)，代表最多等待多少毫秒

线程的中断：interrupt（），让线程中断执行

守护线程：setDaemon（true）

将线程设置为守护线程

线程分为前台线程与守护线程（后台线程）

如果前台线程全部都执行完毕，后台线程无论是否结束都会关闭掉

设置线程优先级

t.setPriorty(1~10);

优先级 1-10

默认优先级 5

优先级高，获得CPU资源的几率就会高，但是也不是一定会最先抢到资源

优先级一样的话，就会按照先来的顺序执行

线程的唤醒与暂停

使用线程的wait（）方法可以让线程暂停，处于停止运行状态；

使用线程的notify（）方法可以唤醒线程，让线程继续运行起来

多线程的异步与同步

多线程操作同一个数据的时候，可能会出现线程安全问题

• 同步：安全性高，效率低
• 异步：安全性低，效率比同步高，会有数据安全性问题

解决异步安全性问题，可以给线程加锁，让代码同步

**线程同步机制：**为了避免多线程的安全问题，需要在公共访问的内容上加锁，加锁之后，当一个线程执行该内容时，其他线程无法执行该内容；只有当线程将次部分的内容执行完毕之后，其他线程才可以执行

加锁流程：

• 找到多线程公共执行内容
• 在此内容上加锁（synchronized）

synchronized可以加在方法上：在返回值前面加关键词即可

加在代码块上时：

synchronized（this）{
    代码块
}

注意：加锁之后，被加锁的代码就变成可同步代码，会影响执行的效率，应该尽量减少锁的范围

示例：

public class ThreadDemo implements Runnable{
    int num = 10;
    public void run(){
        while(true){
            threadName();
        }
    }
}
public synchronized void threadName(){
    if(num>0){     			           System.out.println(Thread.currentThread().getName()+"抢走了第"+num+"张票");
        try{
            Thread.sleep(100);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}
public ststic void main(String[] args){
    ThreadDemo t = new ThreadDemo();
    Thread t1 = new Thread(t,"淘宝");
    Thread t2 = new Thread(t,"12306");
    Thread t3 = new Thread(t,"携程");
    t1.start();
    t2.start();
    t3.start();
}
}

死锁

死锁的问题：

两个线程功能要完全执行，都同时需要两个资源（a，b）

线程1抢到资源a需要等待资源b

线程2抢到资源b需要等待资源a

public class ThreadDemo{
    static Object objA = new Object();
    static Object objB = new Object();
    public static void main(String[] args){
        DeadRunnable td1 = new DeadRunnbale(true);
        DeadRunnable td2 = new DeadRunnbale(false);
    	Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();  
    }
}
class DeadRunnable implement Runnable{
    boolean flag;
    public DeadRunnable(){
        super();
    }
    public DeadRunnable(boolean flag){
        super();
        this.flag = flag;
    }
    @Override
    public void run(){
        if(flag){
            synchronized(ThreadDemo.objA){
                System.out.println("A获取到资源objA");
            }
            synchronized(ThreadDemo.objB){
                System.out.println("A获取到资源objB");
            }
        }else{
            synchronized(ThreadDemo.objA){
                System.out.println("B获取到资源objB");
            }
            synchronized(ThreadDemo.objB){
                System.out.println("B获取到资源objA");
            }
        }
    }  
}