每日一题----------多线程和并发

总结：

两种方式；

（1）继承Thread 类。（由于java是单继承，当该类没有继承其他类时，可以选择继承Thread类）

（2）实现Runnable接口。（当该类继承了其他类，不能继承Thread类时，可以选择实现接口）

1.实现接口的方式 创建一个T1类，来继承Runnable接口，重写run（）方法。

class T1 implements Runnable {
    int count = 0;
    public void run() {
        while (true) {
            System.out.println("count t1: " + (count++));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count == 10) {
                break;
            }
        }
    }
}

讲解代码：

Thread.sleep(1000); ------>代表休眠1000毫秒，也就是1秒的时间，当调用sleep的时候，必须抛出一个异常，可以使用try - catch 捕获异常，也可以将异常抛给该类。

2.在主线程中，创建子线程，也就是由T1这个类创建。

    public static void main(String[] args) {
        T1 t1 = new T1();
        Thread thread1 = new Thread(t1);
        thread1.start();
    }

代码讲解：

首先创建一个T1类的对象，然后将该对象，扔给Thread类中，来实现子线程，由于Thread类是实现了Runnable接口，所有T1也是可以实现这个接口，重写run（）方法，然后来由Thread类来调用方法，启动子线程。

thread1.start（）；就是调用线程，让线程启动。

关于继承方式：

1.创建一个类，直接继承Thread类，来实现Runnable接口。重写run（）方法

class cat extends Thread {
    public void run() {
        int time = 0;
       while (true) {
           try{
               for (int i = 0; i <80 ; i++) {
                   //线程睡眠一会 毫秒级别
                   Thread.sleep(1000);
                   System.out.println("123");
               }
           }catch(Exception e){
               System.out.println("123");
           }
       }
    }
}

2.可以直接创建一个该类对象，调用线程，相比于实现接口的方式，更方便调用，可以对比一下

public static void main(String[] args) {
        cat cat = new cat();
        cat.start();
}

直接可以使用该对象直接调用cat.start（）子线程。

关于线程的一些其他方法（线程礼让和插队）

相比较yield和join方法，这个是线程插队，一旦插队成功，必须执行完，然后其他线程才继续执行，而不是两个线程一起执行。

代码：

public class thread {
    public static void main(String[] args) {
        cat cat = new cat();

        for (int i = 0; i < 100; i++) {

            try {
                Thread.sleep(1000);
                if (i == 5 ){
                    cat.start();
                    cat.join();

                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("主线程正在执行..."+ i);
        }
    }
}
class cat extends Thread {
    public void run() {
        int time = 0;
        boolean loop = true;
       while (loop) {
           try{
               for (int i = 0; i <10 ; i++) {
                   //线程睡眠一会 毫秒级别
                   Thread.sleep(1000);
                   System.out.println("cat正在执行..." + i);
               }
               loop = false;
           }catch(Exception e){
               System.out.println("123");
           }
       }
    }
}

尤其是插入的顺序：

try {
                Thread.sleep(1000);
                if (i == 5 ){
                    cat.start();
                    cat.join();

                }

通过先执行线程，然后在加入。