JAVA 线程1——Thread、Runnable

线程：

一个程序同时执行多个任务，通常每一个任务称为一个线程

多线程：

多线程改变了代码执行方式，从原来的一句一句执行代码改为多个代码片段一起执行
即：从原有的串行操作改变为了并行操作 但是实际上计算机中所有的代码不是同事执行的，

并发:

知识感官上是这样的，微观下CPU执行代码时是这些代码片段中的代码走走停停，CPU在轮寻，这种现象称为并发

进程：

进程是程序一个动态执行过程
进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当程序进入内存运行时，即为线程

附：https://www.cnblogs.com/WuXuanKun/p/6259965.html

如迅雷下载，迅雷软件的一次运行就是一个进程，那么在迅雷中可以同时下载多个电影，这就是多线程（每一个下载都是一个线程）
Jvm是多线程的，在我们运行jvm的时候后台会运行垃圾回收的线程，

线程有两种操作方式：

• 方式一：
• 继承Thread重写run方法
• 方式二：
• 继承Runnable重写run方法

第一种创建线程的方式优点为：简单，直接，在使用匿名内部类创建线程时使用

• 但是缺点也明显：
• 1：由于java是单继承的，这导致我们继承了Thread后就无法继承其他类来重用方法，这在实际开发中很不方便
• 2: 重写run方法会导致将线程要执行的任务定义在了线程中，任务与线程存在必然耦合关系，不利于线程的重用

使用Thread：

public class ThreadDemo {

    public static void main(String[] args) {
        MyThread1 m1 = new MyThread1();
        MyThread2 m2 = new MyThread2();
        m1.start();
        m2.start();
        System.out.println(m1.getX());
    }
}

class MyThread1 extends Thread {
    int x = 0;

    public MyThread1(int x) {
        this.x = x;
    }

    public MyThread1() {
    }

    @Override
    public void run() {
        for (int i = 0; i < 5000; i++) {
            x += i;
        }
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }
}

class MyThread2 extends Thread {
    int y = 0;

    @Override
    public void run() {

        for (int i = 5000; i < 100000; i++) {
            y += i;
        }

    }
}

使用Runnable：

Runnable接口单独定义线程任务

/**
 〈一句话功能简述〉<br>
 * 〈第二种创建线程的案例  Runnable接口单独定义线程任务〉
 *
 * @author 秋水浮萍
 * @create 2019/9/2
 * @since 1.0.0
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        new Thread(new MyRun()).start();
        new Thread(new MyRun2()).start();
    }
}
class MyRun implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <100000 ; i++) {
            System.out.println("还君明珠");
        }
    }
}

class MyRun2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i <100000 ; i++) {
            System.out.println("秋水浮萍");
        }
    }
}

使用匿名内部类完成两种线程：

public class ThreadDemo3 {
    public static void main(String[] args) {
        //第一种
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    System.out.println("你是傻子吗");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };

        Runnable r1=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i <100 ; i++) {
                    System.out.println("对，你就是个傻子");
                    try {
                        Thread.sleep(101);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        new Thread(r1).start();
    }

}

线程提供了一组获取自身信息的相关方法

public class ThreadInfoDemo {
    public static void main(String[] args) {
        //获取主线程
        Thread main = Thread.currentThread();
        String name = main.getName();
        System.out.println(name);
        long id = main.getId();//获取唯一标识
        System.out.println("唯一标识："+id);

        boolean isAlive=main.isAlive();//是否活着
        boolean isDaemon=main.isDaemon();//是否是守护线程
        boolean isInter=main.isInterrupted();//是否被中断了
        System.out.println(isAlive+" "+isDaemon+" "+isInter);

    }
}