java中的多线程

一. 线程的创建

线程的创建方式有两种：

一种是继承Thread类，重写run()方法【这里的run()方法只是普通的方法】，在主方法中，创建该类的对象，调用对象的start()方法。

二种是实现Runnable接口，重写run()方法，在主方法中，以该实现类为参数，创建Thread线程，调用Thread的start()方法。

方式一：示例代码如下

 1 public class Thread01 {
 2     public static void main(String[] args) {
 3         Cat cat = new Cat();
 4         System.out.println("main: "+Thread.currentThread().getName());
 5         cat.start();
 6         System.out.println("hello world");
 7     }
 8 }
 9 
10 class Cat extends Thread{
11     private int num = 0;
12     @Override
13     public void run() {
14         while(true){
15             try {
16                 sleep(1000);
17             } catch (InterruptedException e) {
18                 e.printStackTrace();
19             }
20             System.out.println("我的是小猫" + (++num)+"Thread: " + Thread.currentThread().getName());
21             if(num >= 8){
22                 break;
23             }
24         }
25     }
26 }

方式二：示例代码如下

 1 public class Thread03 {
 2     public static void main(String[] args) {
 3         Thread thread = new Thread(new Dog());
 4         thread.start();
 5 
 6     }
 7 }
 8 class Animal_ {}
 9 class Dog extends Animal_ implements Runnable {
10     @Override
11     public void run() {
12         System.out.println("dog");
13     }
14 }

方式二的另一种写法：【匿名内部类作为参数】

 1 public class Thread03 {
 2     public static void main(String[] args) {
 3 
 4         // 使用匿名内部类，实现Runnable接口，重写run()方法，作为参数。
 5         new Thread(new Runnable() {
 6             @Override
 7             public void run() {
 8                 System.out.println("main: " + Thread.currentThread().getName());
 9             }
10         }).start();
14     }
15 }
16 class Animal_ {}
17 class Dog extends Animal_ implements Runnable {
18     @Override
19     public void run() {
20         System.out.println("dog");
21     }
22 }

两种方式的区别，继承Thread类，只能是单一继承，接口可以实现多个，因此遇到已有继承父类的子类，则必须实现Runnable接口，来创建进程。

方式二的模拟代码如下【静态代理模式】：加深对方式二的理解

public class ProxyThreadTest {
    public static void main(String[] args) {
        Cat1 cat1 = new Cat1();
        ProxyThread proxyThread = new ProxyThread(cat1);// 接口的多态
        proxyThread.start();

    }
}
class Animal{}
// 单一继承，若想使用线程，实现Runnable接口.
class Cat1 extends Animal implements Runnable {
    public Cat1() {
    }

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫");
    }
}
class ProxyThread implements Runnable{
    private Runnable target = null;
    @Override
    public void run() {
        if(target != null){
            target.run(); // 动态绑定
        }
    }

    public ProxyThread(Runnable target) {
        this.target = target;
    }

    public void start(){
        start0();
    }

    private void start0() {
        run();
    }
}

二. 线程的方法

start()：开启线程

run()：Runnable接口定义的方法，注意run()只是普通的方法，如果想让线程开始运作，应该是调用start()方法

yield()：礼让【退让】，在cpu资源不足的情况下，让出自己的cpu和资源

join()：插队，强制让调用该方法的线程执行

三. 守护线程

守护线程：主线程执行完毕，守护线程即使没有执行完成，也要结束

示例代码如下：

public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemon myDaemon = new MyDaemon();
        // 设置守护线程，必须在开启线程之前
        myDaemon.setDaemon(true);
        myDaemon.start();
        for(int i = 0;i < 10;i++){
            System.out.println("宝强辛苦工作");
            Thread.sleep(1000);
        }
    }
}

class MyDaemon extends Thread {
    @Override
    public void run() {
        for(;;){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
            System.out.println("马蓉宋喆聊天...");
        }
    }
}

 四. 线程的生命周期