Java多线程基础

package thread;

//通过类继承Thread类实现创建线程
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat，可以当做线程使用
        Cat cat = new Cat();

        //启动线程,最终会执行Cat的run()方法
        cat.start();
        //当main线程启动一个子线程Thread-0,主线程不会阻塞，会继续执行
        //这时，主线程和子线程是交替执行..
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        //Thread.currentThread().getName()指当前线程的名字
        for (int i = 0; i < 50; i++) {
            System.out.println("主线程i= " + i);
            //主线程休眠
            Thread.sleep(300);
        }
    }
}

//1. Cat继承了 Thread 类， 该类就可以当做线程使用
//2. 重写 run 方法，写自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的 run 方法
class Cat extends Thread {
    int times = 0;

    @Override
    //run方法是一个普通的方法，没有真正的启动一个线程，run方法执行完毕，才向下执行
    public void run() {

        while(true){
            //该线程每隔0.3秒，输出
            System.out.println("喵喵喵~~~" + (++times) + Thread.currentThread().getName() );
            //线程休眠0.3秒  1秒=1000毫秒
            try {
                Thread.sleep(300);//ctrl+alt+t快速处理异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(times == 50){
                break;//当times到达50，退出while，线程也就退出
            }
        }
    }
}

2.1.2 实现Runable接口创建线程

java是单继承的，在某些情况下一个类可能已经继承了某个父类，这是再用继承Thread类方法来创建线程显然不可能了。

通过实现Runnable接口来创建线程，可以避免1.的情况。

package thread;

//通过实现Runable接口，实现创建线程
public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //创建了 Thread 对象，把 dog 对象(实现了 Runnable接口),放入 Thread
        Thread thread1 = new Thread(dog);
        Thread thread2 = new Thread(dog);
        //这里不能用dog调用start()方法，
        thread1.start();
        thread2.start();
    }
}
class Dog implements Runnable{
    int count = 0;
    public void run(){
        while(true){
                System.out.println("小狗汪汪叫~~~" + ++count + Thread.currentThread().getName()) ;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            if(count == 50)
                break;
            }
        }
    }

2.1.3 多线程执行

package thread;

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread2 = new Thread(t2);
        t1.start();
        thread2.start();
    }
}
class T1 extends Thread{
    int counts = 0;

    @Override
    public void run() {
        while(true){
            System.out.println("hello,world!" + ++counts);
            try {
                Thread.sleep( 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(counts == 10)
                break;
        }
    }
}
class T2 implements Runnable{
    int counts = 0;
    @Override
    public void run() {
        while(true){
            System.out.println("hi!" + ++counts);
            try {
                Thread.sleep( 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(counts == 5)
                break;
        }
    }
}