2023.9 - java - 多线程 【Thread &Runable & Callable】

package thread;

/**
 * @author Vince
 * @create 2023-09-14-10:06
 */
public class ThreadAndRunableDifference extends Thread {
    private int count = 5;
    private int length = 5;

    public void run() {
        for (int i = 0; i < 100; i++) {
            if (count > 0) {
                System.out.println("买票" + count--);
            }
        }
    }
}

class RunableDemo1 implements Runnable {
    private int count = 5;
    private int length = 5;

    public void run() {
        for (int i = length; i >= 0; i--) {
            if (count <= 0) {
                System.out.println("货买完了");
            } else {
                count--;
                System.out.println("count " + count);
            }
        }
//        for (int i = 0; i < 100; i++) {
//            if (count > 0) {
//                System.out.println("买票" + count--);
//            }
//        }
    }
}

class test_ThreadAndRunableDifference {
    public static void main(String[] args) {
        /* Thread 操作开始 */
//        ThreadAndRunableDifference demo = new ThreadAndRunableDifference();
//        demo.start();
//        ThreadAndRunableDifference demo1 = new ThreadAndRunableDifference();
//        demo1.start();
//        ThreadAndRunableDifference demo2 = new ThreadAndRunableDifference();
//        demo2.start();
        /* Thread 操作结束 */

        /* Runable 操作开始*/
        RunableDemo1 demon3 = new RunableDemo1();
        Thread demo3 = new Thread(demon3);
        Thread demo4 = new Thread(demon3);
        Thread demo5 = new Thread(demon3);
        demo3.start();
        demo4.start();
        demo5.start();
        /*Runable 操作结束*/
    }
}

java特点：

多线程  、 js：单线程

Thread类 实现方式 ：

一个类 继承了 Thread类 就称为 多线程类 。

【要求】 ：重写 【run】 方法

 【启动】：实例 【start】方法

【缺点】：Thread 类的实例 无法共享数据 ：一共就5张票，却卖了3轮 

Runable接口 实现方式：

【要求】：重写 【run】方法

【必要】：将 Runable 子类实例作为参数  传给 Thread类

【代理模式】：

package thread;

/**
 * @author Vince
 * @create 2023-09-13-22:45
 */
interface Network {
    void getChrome();
}

public class Proxy_pattern implements Network {
    public void getChrome() {
        System.out.println("去谷歌上网");
    }
}

class proxyHandle implements Network {
    private Network network;

    proxyHandle(Network network) {
        this.network = network;
    }

    public void getChrome() {
        if (!this.checkHandleIsLeagle()) {
            try {
                throw new Exception("没有权限");
            } catch (Exception e) {
                System.out.println("程序异常 " + e);
            }
        } else {
            this.network.getChrome();
        }

    }

    boolean checkHandleIsLeagle() {
        System.out.println("非法操作");
        return false;
    }

}

class test_proxy {
    public static void main(String[] args) {
        Proxy_pattern user = new Proxy_pattern();
        proxyHandle proxyHandle_ = new proxyHandle(user);
        proxyHandle_.getChrome();
    }
}

特点：两个类实现同一个接口，A类做目标操作，B类对A类实例做proxy拦截，判断是否让A类实例继续

 Runable 方式只卖了 【5张票】 符合要求。

【引出 Callbale】：

Runable接口的缺点 ：【run】方法没有返回值；

package thread;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @author Vince
 * @create 2023-09-14-16:18
 */
public class CallableDemo implements Callable<String> {
    private int count = 5;

    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            if (count > 0) {
                System.out.println("剩余个数" + this.count--);
            }
        }
        return "票买完了";
    }
}

class test_CallableDemo {
    public static void main(String[] args) throws Exception {
//        CallableDemo m1 = new CallableDemo();
//        FutureTask task1 = new FutureTask(m1);
//        FutureTask task2 = new FutureTask(m1);
//        new Thread(task1).start();
//        new Thread(task2).start();
//        System.out.println(task1.get());
//        System.out.println(task2.get());
        CallableDemo m1 = new CallableDemo();
        CallableDemo m2 = new CallableDemo();
        FutureTask task1 = new FutureTask(m1);
        FutureTask task2 = new FutureTask(m2);
        new Thread(task1).start();
        new Thread(task2).start();
        System.out.println("线程a" + task1.get());
        System.out.println("线程a" + task2.get());

    }
}

这里分析一下  【 Thread 】【Runable】 【Callable】 【FutureTask】 的关系。