• 在单线程的时候，一个程序就是在一个栈里面执行方法，所有的方法不断地在栈内存中压栈出栈，执行的速度慢

• 在多线程的程序中，一个程序可以分为多个线程，一个线程占用一片栈内存，每新开一个线程，就是JVM新开了一片栈内存给我们执行程序，执行完毕之后回收。执行速度快。

• 

• 获取线程的名称

1. 使用thread类中的方法String getName() 返回该线程的名称

2. 先获取当前正在执行的线程，再使用线程的方法getName()也可以拿到名称，static Thread currentThread()可以获取到正在执行的线程

   public class myThread extends Thread{
       public void run(){
           //第一种方式获取并打印线程名称
           System.out.println(getName());
           //第二种方式
           Thread t=Thread.currentThread();
           System.out.println(t.getName());
       }
   }
   

• 设置线程的名字

1. 通过构造函数设置

   首先设置构造函数，一个无参构造，一个有参构造，有参构造里面调用父类的有参构造

2. 通过setName设置

   直接在new一个线程之后通过setName方法设置

   //myThread类
   public class myThread extends Thread{
       public myThread() {
       }
   
       public myThread(String name) {
           super(name);
       }
   
       public void run(){
           Thread t=Thread.currentThread();
           System.out.println(t.getName());
       }
   }
   
   
   //测试类
   public class Test {
       public static void main(String[] args) {
          myThread th=new myThread("zs");
          th.start();
          myThread th1=new myThread();
          th1.setName("ls");
          th1.start();
       }
   }
   
   

• sleep方法

1. public static void sleep(long millis) 使得当前线程睡眠millis毫秒之后继续执行

2. 下面利用sleep方法做一个模拟的秒表

   //myThread类
   public class myThread extends Thread{
       public void run(){
           for (int i=1;i<=60;i++){
               try {
                   Thread.sleep(1000);
               }catch(InterruptedException e)
               {
                   e.printStackTrace();
               }
               System.out.println(i);
           }
       }
     
     //测试类
     public class Test {
       public static void main(String[] args) {
          myThread th=new myThread();
          th.start();
       }
   }
   
   

• 使用Runnable实现多线程

1. 实现一个Runnable接口的实现类

2. 在实现类中重写Runnable接口的run方法，设置线程任务

3. 设置一个实现类的实例对象

4. 创建一个Thread类对象，构造方法中传递Runnable实现类的实例对象

5. 调用Thread类的start方法开启线程

   //Runnableimpl类
   public class Runnableimpl implements Runnable{
       public void run(){
           for (int i=1;i<=10;i++)
           {
               System.out.println(Thread.currentThread().getName()+","+i);
           }
       }
   }
   //测试类
   public class Test {
       public static void main(String[] args) {
           Runnableimpl im=new Runnableimpl();
          Thread th=new Thread(im);
          th.start();
           for (int i = 1; i <=10; i++) {
               System.out.println(Thread.currentThread().getName()+","+i);
           }
       }
   }
   

• 使用Runnable而不是Thread的好处？

• 一个类只能继承自一个父类，我自己写的子类继承了Thread类之后就不能再继承其他类了

• 而使用在实现类中重写Runnable接口之后，我还可以实现其它接口

• 这样做，我就可以增强程序的拓展性，降低了程序的耦合性

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

1. 作用：简化代码
2. 格式：new 父类/接口(){ 重写父类、接口中的方法 };

public class Test {
    public static void main(String[] args) {
        //继承的方式
        Thread th=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 30; i++) {
                    System.out.println("第一种"+i);
                }
            }
        };

        //实现类的方式
        Thread th1=new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        for (int i=0;i<10;i++)
                            System.out.println("第二种"+i);
                    }
                }
        );
        th.start();
        th1.start();
    }
}

• 上面的代码中，我可以不接收new出来的Thread，而是直接在new之后直接利用.start()方法开启线程，但是这样做之后，由于第二个线程在第一个线程执行完之前并没有new出来，那么也就不会被执行，所以这里只是单线程，而像我上面代码写的那样使用Thread对象接收，最后再start，就可以两个线程一起启动。