Java基础：Thread类常用方法，Thread与Runnable的区别，匿名内部类实现线程的创建

Thread类常用方法

一、获取线程的名称：

1.使用Thread类中的方法getName()

•   String getName()返回该线程的名称
  

2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称

•   static Thread currentThread()返回对当前正在执行的线程对象的引用
  

/*线程的名称：
*       主线程：main
*       新线程：Thread-0,Thread-1,...*/
public class Demo01GetThreadName {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();
        new MyThread().start();
        System.out.println(Thread.currentThread().getName());

    }
}
public class MyThread extends Thread {
    @Override
    public void run() {
        //获取线程名称
//        String name = getName();
//        System.out.println(name);

//        Thread t = Thread.currentThread();
//        System.out.println(t);
//        String name = t.getName();
//        System.out.println(name);
        //可以链式编程
        System.out.println(Thread.currentThread().getName());
    }
}

二、设置线程的名称：

1.使用Thread类中的方法setName

•   void setName(String name)改变线程名称，使之与参数name相同。
  

2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名传给父类，让父类(Thread)

• 给子线程起个名字。

•   Thread(String name)分配新的Thread对象
  

package demo02;
public class Demo02SetThreadName {
    public static void main(String[] args) {
        MThread mt = new MThread();
        //*   1.使用Thread类中的方法setName
        mt.setName("小花");
        mt.start();
        //第二种方法
        new MThread("哈哈").start();
    }
}
public class MThread extends Thread{
    //*   2.创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名传给父类，让父类(Thread)

    public MThread(String name) {
        super(name);//调用父类的带参构造方法，把线程名传给父类，让父类给子线程起名
    }

    public MThread() {
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

三、sleep方法，暂停线程

public static void sleep(long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）
* 毫秒数结束后，线程继续执行*/
public class Demo03Sleep {
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 0; i < 20; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);//1000毫秒等于1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

四、run（）方法

此线程中要执行的任务，写在这里面，一般需要在子类或实现类中重写。

五、start（）方法

创建新线程，使此线程开始执行，JVM调用此线程的run方法

Thread与Runnable的区别

Thread与Runnable的区别
如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，很容易的实现资源共享。
总结：
实现Runnable接口比继承Thread类所具有的优势：

• 1.适合多个相同的程序代码的线程去共享同一个资源

• 2.可以避免java中的单继承的局限性
  一个类只能继承一个类，类继承了Thread类就不能继承其他类，
  但实现Runnable接口，还可以继承其他类，实现其他接口

• 3.增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
  实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离

  • 实现类中，重写了run方法：用来设置线程任务
  • 创建Thread类对象，调用start方法：用来开启新线程

• 4.线程池只能放入实现Runnable或Callable类线程，不能直接放入继承Thread的类

扩充：在Java中，每次程序运行至少启动两个线程，一个是main线程，一个是垃圾收集线程。因为每当使用java命令
执行一个类的时候，实际上都会启动一个JVM,每个JVM就是在操作系统中启动了一个进程。

匿名内部类方式实现线程的创建

package demo02;

* 匿名内部类方式实现线程的创建
* 匿名：没有名字
* 内部类：写在其他类内部的类
* 匿名内部类作用：简化代码
*   把子类继承父类，重写父类方法，创建子类对象合成一步完成
*   把实现类实现接口，重写接口中的方法，创建实现类对象合成一步完成
* 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
* 格式：
*   new 父类/接口(){
*       重复父类/接口中的方法
* };
* */
public class Demo05ClassThread {
    public static void main(String[] args) {
        //父类是Thread
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"你好");
                }
            }
        }.start();
        //Runnable接口实现
        Runnable r = new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"哈哈");
                }
            }
        };
        new Thread(r).start();
        //或者也可以把实现类直接写入Thread内
        new Thread(new Runnable(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"哈哈");
                }
            }
        }).start();
    }

}