线程

一、进程

1.定义：运行中的程序

2.特点：独立性、动态性、并发性

二、线程

1.定义：进程中独立运行的代码片段

2.特点：无单独内存、成本低

三、并发

1.定义：即时只有一个cpu，多个进程(线程)在cpu上快速轮换。

2.特点：同一个cpu，同一时间只有一个进程(线程)运行，其它的在等待，假同时。

四、并行

1.定义：同一时间，多个cpu执行多个进程(线程)。

2.特点：互不干扰，真正同时。

五、多线程好处

1.功能上与多进程类似。

2.成本低，效率高。

3.线程共享进程内存，通信方便。

六、后台线程

1.当所有的前台线程结束时，后台线程就死亡(GC);

2.设置：setDaemon(true)。

七、线程的创建与启动

1.继承Thread类(单继承，无法继承其他类)

1）重写run()方法

2）调用start()方法启动线程

3）无返回值，不能抛出异常，因为是覆盖

2.实现Runnable接口

1）重写run()方法

2）调用start()方法启动线程

3）把Runnable对象包装成Thread对象，实现了代码与数据的分离，逻辑更清楚，可以继承其他类。

3.实现Callable接口

1）重写call()方法，有返回值，抛异常。

2）把Callable对象包装成Runnable子类的对象，实现了代码与数据的分离，逻辑更清楚，可以继承其他类。

注意点：

1）多进程：一个操作系统下不同任务，执行不同的程序

2）多线程：一个任务拆成多个子任务，提高效率

3）主线程：执行方法体main()方法

4）主线程死亡，非后台线程依然执行。

补充：

抢占式：多个线程都可以运行但只有一个线程正在运行。“可运行状态”和“运行状态”。

时间片式：为每个线程分配等量的cpu时间的过程

4.代码实现

package 线程;

public class HelloRunner implements Runnable{
    int i;
    public void run() {
        Thread td = Thread.currentThread();
        String name = td.getName();//获取线程名称
        for(i = 0;i<100;i++){
            System.out.println("["+name+"]**"+i);
        }
    }

}

package 线程;

public class TestTHread {
    public static void main(String[] args) {
        Runnable r = new HelloRunner();
        Thread t = new Thread(r);    //创建线程
        t.start();                    //启动线程
        
        Thread td = Thread.currentThread();
        String name = td.getName();//获取线程名称
        for(int i =0;i<100;i++){
            System.out.println("["+name+"]---"+i);
        }
    }
}

5.线程结束

package 线程;

public class HelloRunner implements Runnable{
    int i;
    private boolean stopFlag = false;
    public void run() {
        Thread td = Thread.currentThread();
        String name = td.getName();//获取线程名称
        for(i = 0;i<100;i++){
            System.out.println("["+name+"]**"+i);
        }
        
        while(!stopFlag){
            System.out.print((i++) + "   ");
            if(i>500){
                i = 0;
            }
        }
        
    }
    public void setStopFlag(boolean stopFlag){
        this.stopFlag=stopFlag;
    }
}

package 线程;

public class TestTHread {
    public static void main(String[] args) {
        Runnable r = new HelloRunner();
        Thread t = new Thread(r);    //创建线程
        t.start();                    //启动线程
        
        Thread td = Thread.currentThread();
        String name = td.getName();//获取线程名称
        for(int i =0;i<100;i++){
            System.out.println("["+name+"]---"+i);
        }
        HelloRunner hr = new HelloRunner();
        hr.setStopFlag(true);
    }
}

6.继承Thread

package 线程;

public class HelloThread extends Thread{
    int i;
    @Override
    public void run() {
        for(i=0;i<100;i++){
            System.out.println("---"+i);
        }
    }
    public static void main(String[] args) {
        Thread t = new HelloThread();
        t.start();
    }
}

八、方式比较

1.实现Runnable接口

1）更好的面向对象设计

2）可以继承其他类

3）保持了模块功能的独立性

2.继承Thread

1）代码更简洁

九、线程控制

1.sleep方法

1）使用：Thread.sleep(100);//睡眠100毫秒

2）唤醒方式：

　　主动唤醒-到达指定睡眠时间

　　被动唤醒-调用interrupt方法，收到InterruptedException异常

2.jion方法(实例方法)

1）jion方法有重载方法可以使用，以允许指定线程最小等待时间。

2）唤醒方式：

　　线程结束唤醒-当所有jion的线程运行结束后

　　主动唤醒-到达指定睡眠时间

　　被动唤醒-调用interrupt方法，收到InterruptedException异常

3.线程阻塞状态

新建->start()->可运行<---调度任务--> 正在运行->run()完成->终止

正在运行---阻塞事件(sleep，join)----->阻塞-----解除阻塞---->可运行

4.方法使用

package 线程;

public class sleepandjion {
    public static void main(String[] args) {
        Thread t = new Thread();
        try {
            t.sleep(1000);
            t.join();
            t.join(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}