实现多线程

进程和线程的区别

进程：是正在运行的程序

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

多线程的实现方式

在java.lang下

方式一：继承Thread类

定义一个类MyThread继承Thread类
在MyThread中重写run()方法，因为run()方法是用来封装被执行线程的代码
创建MyThread类对象
启动线程

public class ThreadDemo {
    public static void main(String[] args){
        MyThread my1=new MyThread("杨天伦");
        MyThread my2=new MyThread("李昊");
        my1.start();
        my2.start();//void start()导致线程开始执行；java虚拟机调用此线程的run方法
    }
}

run和start的区别：
<font color=’red’> run():封装线程执行的代码，直接调用，相当于普通方法的调用
<font color=’red’> start():启动线程;然后由JVM调用此线程的run()方法

设置线程名称

通过setName和getName
带参构造方法（需要super带参调用父类构造方法）以及**Thread.currentThread().getName()**获取

线程调度

分时调度模型:所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
抢占式调度模型:优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU 时间片相对多—些

Java使用的是抢占式调度模型

Thread类中提供两个方法用来设置和获取线程优先级：
public final int getPriority):返回此线程的优先级
public final void setPriority(int newPriority):更改此线程的优先级

线程的优先级有范围，最高是10，最低1，默认5
线程优先级高仅仅表示线程获取CPU时间片的几率高，需要在次数比较多，或者多次运行时才能看到效果

线程控制

方法名	说明
static void sleep(long millis)	使当前正在执行的线程停留（暂停执行）指定的毫秒数
void join()	等待这个进程死亡
void setDaemon(boolean on)	将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出

sleep代码示例

public class ThreadSleep extends Thread{
    @Override
    public void run(){
        for (int i=0;i<99;i++){
            System.out.println(getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadSleepDemo {
    public static void main(String[] args){
        ThreadSleep ts1=new ThreadSleep();
        ThreadSleep ts2=new ThreadSleep();
        ThreadSleep ts3=new ThreadSleep();
        ts1.setName("朱长坤");
        ts2.setName("李昊");
        ts3.setName("杨天伦");

        ts1.start();
        ts2.start();
        ts3.start();
    }
}

join代码示例

public class ThreadJoin extends Thread{
    @Override
    public void run(){
        for (int i=0;i<99;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

public class ThreadJoinDemo {
    public static void main(String[] args) {
        ThreadJoin tj1=new ThreadJoin();
        ThreadJoin tj2=new ThreadJoin();
        ThreadJoin tj3=new ThreadJoin();

        tj1.setName("李昊");
        tj2.setName("杨天伦");
        tj3.setName("朱长坤");

        tj1.start();
        try {
            tj1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        tj2.start();
        tj3.start();

    }
}

setDaemon代码示例

public class ThreadDaemon extends Thread {
    @Override
    public void run(){
        for (int i=0;i<99;i++){
            System.out.println(getName()+":"+i);
        }
    }
}

public class ThreadDaemonDemo {
    public static void main(String[] args) {
        ThreadDaemon td1=new ThreadDaemon();
        ThreadDaemon td2=new ThreadDaemon();

        td1.setName("李昊");
        td2.setName("杨天伦");
        Thread.currentThread().setName("任然");
        td1.setDaemon(true);
        td2.setDaemon(true);
        td1.start();
        td2.start();
        for (int i=0;i<9;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

线程生命周期

线程的生命周期

方式二：实现Runnable接口

定义一个类MyRunnable实现Runnable接口
在MyRunnable类中重写run()方法
创建MyRunnable类的对象
创建Thread类对象，把MyRunnable对象作为构造方法的参数
启动线程

public class MyRunnable implements Runnable{
    @Override
    public void run(){
        for (int i=0;i<99;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class MyRunnableDemo {
    public static void main(String[] args) {
        MyRunnable my=new MyRunnable();

        Thread t1=new Thread(my,"杨天伦");
        Thread t2=new Thread(my,"李昊");
        t1.start();
        t2.start();
    }
}