多线程的常用方法

1、创建线程有两种办法：

        1.1继承Thread类

        1.2实现Runnable接口

实际开发中一般使用第二种方法，面向接口开发

package com.bjpowernode.javase.day28.Threads;

public class ThreadTest01 {
    public static void main(String[] args) {
        MyThread mt=new MyThread();
        mt.start();

        Thread t=new Thread(new MyRunnable());
        t.start();
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread()+"主线程执行--->"+i);
        }


    }
}
class MyThread extends Thread{



    @Override
    public void run() {
       for(int i=0;i<100;i++)
           System.out.println(Thread.currentThread().getName()+"分支线程执行--->"+i);
    }
}
class MyRunnable implements Runnable {

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"分支线程执行-->"+i);
        }
    }
}

运行效果图：

这里发生了cpu时间片抢夺，只要某个线程被调用了start()方法，就进入了就绪状态，进入就绪状态之后就具备了抢夺cpu时间片的权利。

这里也可以采用匿名内部类的方式进行创建线程对象，实际上是第二种方式的拓展：

package com.bjpowernode.javase.day28.Threads;
/*采用匿名内部类*/
public class ThreadTest02 {
    public static void main(String[] args) {
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<100;i++){
                    System.out.println(Thread.currentThread().getName()+"分支线程执行");
                }
            }
        });
        t1.start();
        for(int i=0;i<100;i++){
            System.out.println("main方法执行"+i);
        }



    }
}

运行效果图：

2、获取当前线程的方法，CurrentThread()方法

        静态方法，出现在哪块代码中就返回哪一个线程

package com.bjpowernode.javase.day28.Threads;
/*CurrentThread
* CurrentThread就是当前线程
* 这个代码出现在main方法当中，所以当前线程就是主线程*/
public class ThreadTest03 {
    public static void main(String[] args) {
        //创建线程对象
        Thread t1=new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<100;i++){
                    System.out.println("--->分支线程"+Thread.currentThread().getName()+i);
                }
            }
        });
        t1.start();
        MyThread2 mt2=new MyThread2();
        mt2.start();

    }
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(Thread.currentThread().getName()+"--->分支线程执行"+i);
        }
    }
}

效果图：

3、常见的Thread方法

3.1怎么获取当前线程对象？
    Thread t=Thread.currentThread();
    返回值t就是当前线程
3.2获取线程对象的名字
    String name=线程对象.getName();
3.3修改线程对象的名字
    线程对象.setName("线程名字");
3.4当线程对象没有名字的时候，默认的名字有什么规律呢？
    Thread-0
    Thread-1
    Thread-2
    Thread-3
        .....*/

public class ThreadTest04 {
    public static void main(String[] args) {
        TestClass t1=new TestClass();
        t1.setName("继承Thread方式创建的Thread--->t1");
        t1.start();

        Thread t2=new Thread(new TestClass02());
        t2.setName("实现Ruannable方式创建的Thread--->t2");
        t2.start();
    }

}
class TestClass extends Thread{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行");
    }
}
class TestClass02 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"执行");
    }
}

效果图：

 4、线程睡眠和终止睡眠方法：

Thread.sleep(睡眠时间：毫秒)

静态方法，出现在哪个线程中，哪个线程就会休眠，与引用无关

Thread.interupt()方法

终止线程方法：stop和boolean标记

/*多线程的睡眠方法
* static void sleep(long millis)
* 静态方法，参数是毫秒
* 作用：让当前线程进入休眠期，进入阻塞状态，放弃占用cpu时间片，让给其他线程使用
*   这行代码出现在A线程中，A线程就会进入休眠
*   这行代码出现在B线程中，B线程就会进入休眠
*
*    唤醒一个休眠的线程Thread.interupt();
*       这种唤醒方式是利用异常处理机制来实现的
*
*   java中终止一个线程的执行可以用Thread.stop()方法
*   但是不推荐使用，强制终止线程会导致丢失数据
*   一般设置一个boolean标记，用boolean标记来终止线程
* */
public class ThreadTest05 {
    public static void main(String[] args) {
        Myrunnable4 r=new Myrunnable4();
        Thread t=new Thread(r);
        t.setName("t");
        t.start();
        try {
            Thread.sleep(1000*5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"线程执行");
        t.stop();
    }
}
class Myrunnable4 implements Runnable{
    boolean run=true;
    @Override
    public void run() {
        if(run){
            System.out.println(Thread.currentThread().getName()+"--->执行");
            try{
                //睡眠一年
                Thread.sleep(1000*60*60*24*365);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--->结束");
        }
    }




}

效果图：

这里的t--->执行到main线程执行中间休眠了5秒