创建多线程的几种方式

线程周期：

1、新建状态：使用new关键字或者Thread类或其他子类创建一个线程对象之后，该线程就处于新建状态，他保持这个状态知道程序start()这个状态。

2、就绪状态：当线程对象调用了stsrt()方法后，这个线程就进入了就绪状态，就绪状态处于就绪队列中，要等待IVM中线程调度器的调度。

3、运行状态：如果线程获取了CPU资源，就可以执行run()方法，这个时候线程就处于运行状态，这个状态的线程是最复杂的，它可以变为：阻塞状态，死亡状态，就绪状态

4、阻塞状态：如果一个线程执行了sleep()、suspend()等方法，失去了所占用的资源之后，该线程就从运行状态进入阻塞状态，在重新获得设备资源后重新进入就绪状态。可以分为三种情况：

（1）等待阻塞：运行中的线程执行wait()方法，线程进入等待阻塞状态。

（2）同步阻塞：获取synchronized 同步锁失败。

（3）其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态

5、死亡状态：一个运行状态的线程完成任务或者其他终止条件发生时，这个线程就到终止死亡状态。

---

创建线程：

Runnable接口

Thread类本身

Callable和Future创建

线程池

---

Runnable：

package Thread;

public class thread_runnable {

    public static void main(String[] args) {

        RunnableDemo R1 = new RunnableDemo( "Thread-1");

        R1.start();

        RunnableDemo R2 = new RunnableDemo( "Thread-2");

        R2.start();

        }

    }

    class RunnableDemo implements Runnable {

        private Thread t;

        private String threadname;

        RunnableDemo(String name){

            threadname = name;

            System.out.println("创建线程" + threadname);

        }

        @Override

        public void run() {

            System.out.println("运行" + threadname);

            for(int i = 4; i > 0;i-- ){

                System.out.println("线程运行中"+threadname+"--"+i);

                try {

                    Thread.sleep(50);

                } catch (InterruptedException e) {

                }

                System.out.println("线程 " +  threadname + " 阻塞.");

            }

            System.out.println("线程 " +  threadname + " 退出.");

        }

        public void start() {

            System.out.println("就绪 " +  threadname );

            if (t == null) {

                t = new Thread (this, threadname);

                t.start ();

        }

    }

}

Thread类其实和Runnable差不多，本质上也是实现了Runnable接口。把 implements Runnable更换为extends Thread就可以了。

 

---

第三种方式：
    实现callable接口
    优点：可以获取线程的执行结果
    缺点：效率低，可能会曹诚阻塞

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        //第一步：创建一个“未来任务类”对象
        FutureTask task = new FutureTask(new Callable() {
            @Override
            public Object call() throws Exception { //call()方法就相当于run()方法，只不过这个有返回值
                System.out.println("开始");
                Thread.sleep(1000 * 10);
                System.out.println("结束");
                int a = 100;
                int b = 200;
                return a + b;
            }
        });
        Thread t = new Thread(task);
        t.start();
        //get()的执行可能会导致当前现成的额阻塞
        Object o = task.get();
        System.out.println(o);
        System.out.println("hello world !!!");
    }

 

---

线程池创建：

线程池提供了一个线程队列，队列中就保持着等待的线程，避免每次都要创建线程和销毁线程带来的额外成本，从而提高效率。

public class ThreadPoolExecutorTest {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        ThreadPool threadPool = new ThreadPool();
        for(int i =0;i<5;i++){
            executorService.submit(threadPool);
        }
        executorService.shutdown();
    }
}
class ThreadPool implements Runnable {
    @Override
    public void run() {
        for(int i = 0 ;i<10;i++){
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }

}

---

Thread.currentThread()和This的区别

Thread.currentThread()表示当前代码段正在被哪个线程调用

this表示的是当前对象，

实例代码：

package Thread;

public class Demo {

    public static void main(String[] args) {

        MyThread myThread=new MyThread();

        Thread thread=new Thread(myThread);

        thread.start();

    }

    public static class MyThread extends Thread {

        public MyThread() {

            System.out.println("当前线程的名字："+Thread.currentThread().getName());

            System.out.println("当前线程的名字："+this.getName());

        }

        @Override

        public void run() {

            //isAlive判断当前的线程是否处于活动状态

            System.out.println("当前线程的名字："+Thread.currentThread().getName()+"   run=="+Thread.currentThread().isAlive());

            System.out.println("当前线程的名字："+this.getName()+"  run=="+this.isAlive());

        }

    }

}

运行结果：

当前线程的名字：main

当前线程的名字：Thread-0

当前线程的名字：Thread-1   run==true

当前线程的名字：Thread-0  run==false  //这一块为false是因为仅仅运行了构造方法，并没有运行线程