多线程-常用方法-线程阻塞-合理终止阻塞

常用方法：

1、获取当前线程对象： Thread name= Thread.currentThread().getName(); 返回值name就是当前线程。
2、获取线程对象的名字：String name = 线程对象.getName();
3、设置线程对象的名字：线程对象.setName("线程名字");

//获取当前线程的名字
String name = Thread.currentThread().getName();
System.out.println(name + "-->" + i);

//获取当前线程的名字
Thread currentThread = Thread.currentThread();
System.out.println(currentThread.getName() + "-->" + i);

线程阻塞：

关于线程的sleep方法： static void sleep(long millis)
1、静态方法：Thread.sleep(1000);
2、参数是毫秒
3、作用：让当前线程进入休眠，进入“阻塞状态”，放弃占有CPU时间片，让给其它线程使用。
4、这行代码出现在A线程中，A线程就会进入休眠。这行代码出现在B线程中，B线程就会进入休眠。
5、Thread.sleep()方法，效果：间隔特定的时间，去执行一段特定的代码，每隔多久执行一次。

/*判断题：让当前线程进入休眠！！当前！！！！ */
public class ThreadTest07 {
    public static void main(String[] args) {
        // 创建线程对象
        Thread t = new MyThread3();
        t.setName("t");
        t.start();

        // 调用sleep方法
        try {
            // 问题：这行代码会让线程t进入休眠状态吗？
            t.sleep(1000 * 5); 
            // 在执行的时候还是会转换成：Thread.sleep(1000 * 5);
           // 这行代码的作用是：让当前线程进入休眠，也就是说main线程进入休眠。
           // 这样代码出现在main方法中，main线程睡眠。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 5秒之后这里才会执行。
        System.out.println("hello World!");
    }
}

class MyThread3 extends Thread {
    public void run(){
        for(int i = 0; i < 10000; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

合理终止阻塞：

/*
怎么合理的终止一个线程的执行。这种方式是很常用的。
 */
public class ThreadTest10 {
    public static void main(String[] args) {
        MyRunable4 r = new MyRunable4();
        Thread t = new Thread(r);
        t.setName("t");
        t.start();

        // 模拟5秒
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终止线程，想要什么时候终止t的执行，那么你把标记修改为false，就结束了。
        r.run = false;
    }
}

public class MyRunable4 implements Runnable {
    // 打一个布尔标记
    boolean run = true;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            if(run){
                System.out.println(Thread.currentThread().getName() + "--->" + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else{
                // return就结束了，在结束之前还有什么没保存的。
                // 在这里可以保存。
                //save....

                //终止当前线程
                return;
            }
        }
    }
}

强行终止线程阻塞：

1、interrunpt(); 通过异常机制来终止线程睡眠

2、stop(); 强行终止线程阻塞，会导致数据丢失

/*
sleep睡眠太久了，如果希望半道上醒来，你应该怎么办？
也就是说怎么叫醒一个正在睡眠的线程？？
注意：这个不是终断线程的执行，是终止线程的睡眠。
 */
public class ThreadTest08 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable2());
        t.setName("t");
        t.start();

        // 希望5秒之后，t线程醒来
        try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 终断t线程的睡眠：这种终断睡眠的方式依靠了java的异常处理机制。
        t.interrupt();
    }
}

public class MyRunnable2 implements Runnable {

    // 重点：run()当中的异常不能throws，只能try catch
    // 因为run()方法在父类中没有抛出任何异常，子类不能比父类抛出更多的异常。
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "---> begin");
        try {
            // 睡眠1年
            Thread.sleep(1000 * 60 * 60 * 24);
        } catch (InterruptedException e) {
            // 打印异常信息
            //e.printStackTrace();
        }
        //1天之后才会执行这里
        System.out.println(Thread.currentThread().getName() + "---> end");

        // 调用doOther
        //doOther();
    }
}