关于java:创建实现多线程

35次阅读

共计 1564 个字符，预计需要花费 4 分钟才能阅读完成。

1. 继承 Thread，重写 run 办法。

public class MyThread extends Thread {
    @Override
    public void run() {
        int i = 0;
        while(i < 100){
            i++;
            System.out.println("thread: i ="+i);
        }
    }
}

class Demo{public static void main(String[] args) {MyThread myThread = new MyThread();
        myThread.start();
        for (int j = 0; j < 100; j++) {System.out.println("main: j ="+j);
        }        
    }
}

2. 实现 Runnable 接口

public class CountTask implements Runnable {
    @Override
    public void run() {
        int i = 0;
        while(i < 100){
            i++;
            System.out.println("thread: i ="+i);
        }
    }
}

class Demo22{public static void main(String[] args) {Thread thread = new Thread(new CountTask());
        thread.start();}
}

3、实现 Callable 接口 **

通过实现 Callable 接口并重写 call 办法，并把 Callable 实例传给 FutureTask 对象，再把 FutureTask 对象传给 Thread 对象。它与 Thread、Runnable 最大的不同是 Callable 能返回一个异步解决的后果 Future 对象并能抛出异样，而其余两种不能。

调用 Thread 类型对象的 start() 办法。留神如果调用 run() 办法的话，只是简略的办法调用，而不是开启一条新的线程。

在 Thread 类的源码中能够看到定义了以下的线程的状态

状态	含意	详情
NEW	新建	线程被创立了，但未开始运行
RUNNABLE	可运行	调用 start()后会变成该状态。该状态的线程位于可运行线程池中，变得可运行，期待获取 cpu 的执行权
BLOCKED	阻塞	表明以后线程（A）正在期待获取一个 `锁`（L），获取锁后能力进入或再次进入 `同步的` 代码块或办法（即临界区）。当另一条持有这个锁的线程（B），调用了锁对象（L）的 wait()办法后，以后线程（A 线程）才有机会获取到锁（L）
WAITING	期待	以后线程（A）已取得 `锁`了，已在临界区中。当调用了 `Object.wait()、Thread.join()、LockSupport.park()` 等办法（都不蕴含超时参数）后就会进入到期待状态。`期待` 的含意是以后线程（A）正在期待其它线程（B）执行对应的操作，以后线程能力回到 RUNNABLE 状态。`比方：` A 线程调用了 Object.wait()，那么 A 须要期待 B 线程调用 Object.notify()或 Object.notifyAll()，A 能力回到 RUNNABLE 状态；A 线程调用了 B 线程的 join()，表明 A 须要期待 B 执行完，能力回到 RUNNABLE 状态，才有机会取得 cpu 执行权持续运行代码。
TIMED_WAITING	期待超时	以后线程（A）已取得 `锁`了，已在临界区中。当调用了以下办法，就会进入期待超时的状态（含超时参数）：`Thread.sleep()、Object.wait()、Thread.join()、LockSupport.parkNanos、LockSupport.parkUntil`。请留神`wait 和 sleep 的区别：`wait 是 Object 上的办法，sleep 是 Thread 上的办法。wait 会开释锁，但 sleep 不会开释锁。
TERMINATED	终结	Thread.run()办法运行完，就进入该状态