JAVA笔记13__创建线程/线程休眠/等待线程终止/线程中断/守护线程

/**
 * 线程：是进程的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个进程（单线程程序）
 * 多线程两种实现方法：1.继承Thread类       2.实现Runnable接口
 */
public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        t1.start(); //启动线程
        System.out.println("main");
        System.out.println("finished.");
        MyRunnable ta = new MyRunnable();
        Thread t2 = new Thread(ta);
        t2.start();
        
    }
}
    
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<10;++i){
            System.out.println(new Date()+"-"+i);
        }
    }
}

class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
    @Override
    public void run() {
        for(int i=0;i<10;++i){
            System.out.println("MyRunnable"+"-"+i);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("当前运行的线程名称："+Thread.currentThread().getName()); //输出main
        Thread t1 = new Thread(new MyRunnable(),"fish7");
//        System.out.println(t1.getId());
        t1.setName("dining");
        System.out.println("t1线程是否活动？"+t1.isAlive());
        t1.start();
        System.out.println("t1线程是否活动？"+t1.isAlive());
    }
}

class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
    @Override
    public void run() {
        System.out.println("当前运行的线程名称："+Thread.currentThread().getName()); //输出main
    }
}

public class Main {
    /**
     * Sleep方法原理：让当前线程进入休眠状态，让出当次执行的CPU时间，但是不释放监视器的所属权
     */
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for(int i=0;i<10;++i){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                Thread.sleep(1000); //不丢失任何监视器的所属权
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
    @Override
    public void run() {
        for(int i=0;i<10;++i){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

public class Main {
    /**
     * Join方法：等待当前线程执行终止，或指定的等待时间（毫秒，纳秒）
     */
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for(int i=0;i<10;++i){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                if(i==5)
                    t1.join(); //等待该线程结束
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

class MyRunnable implements Runnable{ //推荐使用这个（可以继承其它类，第一种继承了Thread就不能继承其他的）
    @Override
    public void run() {
        for(int i=0;i<10;++i){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

public class Main {
    /**
     * interrup方法：只是设置了线程的中断状态为true，并没有真正地中断线程。
     */
    public static void main(String[] args) {
        Thread t1 = new Thread(new MyRunnable());
        t1.start();
        for(int i=0;i<10;++i){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                if(i==5)
                    t1.interrupt(); //中断线程，设置了一个中断标记（中断状态为true）
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        int i = 0;
        while(!Thread.interrupted()){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                ++i;
                Thread.sleep(1000); //如果中断标记为true，会抛出异常
            } catch (InterruptedException ex) {
                ex.printStackTrace();
                Thread.currentThread().interrupt();
            }
        }
    }
}

public class Main {
    /**
     * 自定义标记完成中断线程   *被中断的程序只能自己去中断，别人不得中断它。
     */
    public static void main(String[] args) {
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my);
        t1.setPriority(Thread.MAX_PRIORITY); //设置线程的
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        t1.start(); 
        for(int i=0;i<10;++i){
            try {
                System.out.println("当前运行的线程名称："+Thread.currentThread().getName()+"-"+i);
                if(i==5){
                    my.setFlag(false); //中断线程
                }
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

class MyRunnable implements Runnable{
    private boolean flag = true;
    public boolean isFlag(){
        return flag;
    }
    public void setFlag(boolean flag){
        this.flag = flag;
    }
    @Override
    public void run() {
        int i = 0;
        while(flag){
            System.out.println(Thread.currentThread().getName()+"-"+i);
            i++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

public class Main {
    /**
     * 守护线程：当程序中没有用户线程的时候所有守护线程都会自动终止！（守护用户线程）
     * setDaemon：将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java虚拟机退出。
     *            该方法必须在启动线程前调用。
     * yield：暂停当前正在执行的线程对象，并执行其他线程。
     */
    public static void main(String[] args) { //主线程是用户线程
        MyRunnable my = new MyRunnable();
        Thread t1 = new Thread(my);
        t1.setDaemon(true); //设置线程为守护线程
        System.out.println(t1.isDaemon());
        t1.start(); 
        for(int i=0;i<10;++i){
            System.out.println("main-"+i);
            if(i==5){
                Thread.yield(); //让出当次CPU的执行时间
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<20;++i){
            System.out.println("MyRunnablei"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    }
}