Java自学笔记——线程

Java自学笔记——线程

基本概念

• 进程：运行中的程序，操作系统会为进程分配内存空间，有产生、存在、消亡的过程
• 线程：线程由进程创建，是进程的一个实体，一个进程可以有多个线程

• 单线程 多线程(可以执行多个进程)

• 并发（多任务交替执行，单核CPU）
• 并行（同一时刻，多个任务同时执行，多核CPU） 并发并行可能同时存在

实现方式

一、继承Thread类

/*
1.继承Thread类，该类可以当作线程使用
2.重写run()方法，Thread类实现了Runnable接口的run()方法
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
*/
class Cat extends Thread {
    @Override
    public void run() {
        int time = 0;
        while (true) {
            //每隔一秒输出
            System.out.println("我是小喵咪"+(++time)+"线程名称"+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(time == 10){
                break;
            }
        }
    }
}

使用

1. 创建对象 Cat cat = new Cat();
2. 调用start() cat.start();

/**
 * @author Lspero
 * @version 1.0
 * 继承Thread类实现多线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException{
        //创建Cat对象，可以当作线程使用
        Cat cat = new Cat();
        //run()方法就是一个普通方法，由main()线程调用，就会把run()方法执行完毕才向下执行，会阻塞
        //cat.run();
        //启动线程->执行cat的run()方法
        cat.start();
        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0()是本地方法，JVM调用，底层是C/C++实现
            //真正实现多线程的是start0，而不是run
             private native void start0();
         */
        //当main线程启动一个子线程Thread-0,主线程main不会阻塞
        //主线程子线程交替执行，所用线程结束时进程(Application)才结束
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程i="+i);
            //主线程休眠
            Thread.sleep(1000);
        }
    }
}

二、实现Runnable接口

class Dog implements Runnable{
    int count = 0;

    @Override
    public void run() {//普通方法
        while (true){
            System.out.println("小狗"+(++count)+Thread.currentThread().getName());
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            if(count == 10){
                break;
            }
        }
    }
}

使用
3. 创建对象 Dog dog = new Dog();
4. 创建Thread对象，把Dog对象(实现Runnable接口)放入Thread
Thread thread = new Thread(dog);
5. 调用thread的start()方法 thread.start();

/**
 * @author Lspero
 * @version 1.0
 * 实现Runnable接口实现多线程
 */
//实现Runnable接口更适合多线程共享一个资源的情况
//可以多个线程执行同一个run()方法
//建议使用Runnable接口
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start();不能调用start()
        //创建Thread对象，把Dog对象(实现Runnable接口)放入Thread
        //底层使用了设计模式(代理模式)
        Thread thread = new Thread(dog);
        thread.start();

        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}

代理模式模拟

//线程代理类，模拟一个极简的Thread类
class ThreadProxy implements Runnable{//Proxy类当作Thread类

    private Runnable target = null;//属性，Runnable类型

    @Override
    public void run() {
        if(target != null){
            target.run();//动态绑定
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start(){
        start0();//最重要，真正实现多线程方法，模拟
    }

    public void start0(){
        target.run();
    }

}

线程的退出

1. 运行结束自动退出
2. 外部通知被动退出（利用变量实现）

/**
 * @author Lspero
 * @version 1.0
 * 线程外部通知的方式被动退出
 */
public class ThreadExit {
    public static void main(String[] args) {
        T t = new T();
        t.start();

        //通知方式
        //如果希望main线程控制t线程终止，必须可以修改loop,让退出run()方法，从而终止t线程

        //让main方法休眠10s，再通知t线程退出
        try {
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t.setLoop(false);
    }
}

class T extends Thread{
    private int count = 0;
    private boolean loop = true;

    public boolean isLoop() {
        return loop;
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    @Override
    public void run() {
        while (loop){
            System.out.println((++count) + "运行中...");
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}