多线程-继承Thread和实现Runnable

继承Thread实现多线程

实现多线程需要继承Thread类，并实现run方法

class MyThread extends Thread{
    @Override
    public void run() {
	//这里的代码 就是一条执行路径。
    }
}

run方法就是线程要执行的任务方法,这个执行路径的触发方式不是调用run方法，而是通过Thread对象的start()来启动任务

public static void main(String[] args) {
    MyThread m = new MyThread();
    m.start();
    }

main线程与Mythread线程并发执行（同一时段开始），谁先执行完成，不能确定。

每个线程都拥有自己的栈空间，共用一份堆空间。

实现Runnable实现多线程

实现多线程也可以让类实现Runnable接口，并实现run方法，来创建一个给线程执行的任务，最后分配给线程来实现。

class MyRunnable implements Runnable{
	
    @Override
    public void run() {
	//线程执行的任务
    }
}

触发方式依然为通过Thread的start方法完成

public static void main(String[] args) {
    //1. 创建一个任务对象    
    MyRunnable r = new MyRunnable();
    //2. 创建一个线程， 并为其分配一个任务
    Thread t = new Thread(r);
    //3. 执行这个线程
    t.start();
    }

实现Runnable与继承Thread相比有如下优势

1. 通过创建任务，然后给线程分配的方式来实现多线程， 更适合多个线程同时执行相同任务的情况。
2. 可以避免单继承所带来的局限性。
3. 任务与线程本身是分离的， 提高了程序的健壮性。
4. 线程池技术，可以接受Runnable类型的任务， 不接受Thread类型的线程。

虽然通过实现Runnable的方式实现多线程有更多的好处，但是继承Thread的方式实现多线程有时也会使用，例如对于只需要执行一次的线程，可以通过内部类的方式创建，更方便创建使用。

public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
			//这里的代码 就是一条执行路径。
            }
        }.start();
    }

Thread常用构造方法

常用构造方法1

Thread t = new Thread();

常用构造方法2

//创建任务对象r
MyRunnable r = new MyRunnable();
//传入任务对象r
Thread t = new Thread(r);

常用构造方法3

//创建任务对象
MyRunnable r = new MyRunnable();
//传入任务对象，进程名
Thread t = new Thread(r,"one");

常用构造方法4

//传入进程名
Thread t = new Thread("one");

Thread常用方法

1.getName(获取线程名称)

getName方法1

//传入进程名
Thread t = new Thread("one");
//打印进程名
System.out.println(t.getName());

getName方法2

class MyRunnable implements Runnable{
    @Override
    public void run() {
    	//当前线程名称
        Thread.currentThread().getName();
    }
}

2.getId(获取线程Id)

Thread t = new Thread("one");
//打印进程Id(系统生成)
System.out.println(t.getId());

3.getpriority(获得线程优先级)

4.setpriority(设置线程优先级)

5.start

//创建一个线程， 并为其分配一个任务
Thread t = new Thread(r);
//执行这个线程
t.start();

6.sleep(休眠)

//线程休眠1000毫秒（1000毫秒=1秒）
Thread.sleep(1000);
//线程休眠1000毫秒+1纳秒
Thread.sleep(1000,1);

7.setDaemon(守护线程/用户线程)

• 线程： 分为守护线程和用户线程
• 用户线程： 当一个进程不包含任何的存活用户线程时， 进程结束。（直接创建的线程都是用户线程）
• 守护线程： 用于守护用户线程的，当最后一个用户线程结束时，守护线程自动死亡。

MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        //设置t为守护线程
        t.setDaemon(true);

８.currentThread(获取当前线程对象)

Thread.currentThread()

线程中断

• 一个线程是一个独立的执行路径， 它是否结束， 应该由其自身决定。
• 由外部干涉一个完整的执行流程死亡是不合理的。

//正确结束流程示范
public class Test {
    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread t = new Thread(r);
        t.start();
        //给线程t标记，进入catch块
        t.interrupt();
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(1000000);
        } catch (InterruptedException e) {
            //线程自主结束
            return;
        }
    }
}