创建多线程Extend,Runnable,Callable

1.继承 Thread类

//一共有三个进程，其中一个是进程自身的主线程
public class ExtendThread extends Thread
{
    private int i ;           //每个线程对象不同，所以资源肯定不同
    public void run()
    {
        for ( ; i < 100 ; i++ )
        {
            //默认名字是Thread-0，Thread-1，Thread-2
            //或者//System.out.println(this.getName() +  " " + i);
            System.out.println(getName() +  " " + i);

            //这里获取名字方法区别implements runnable接口的类
        }
    }
    public static void main(String[] args)
    {
        for (int i = 0; i < 100;  i++)
        {
            // 主线程
            System.out.println(Thread.currentThread().getName()
                    +  " " + i);
            if (i == 20)
            {
                // 两个新线程分别输出100次，总共200次
                // 区别实现runnable接口的target（多个线程用一个target，共享变量，输出一个100次）
                new ExtendThread().start();
                new ExtendThread().start();

                try {
                    //希望 子线程在start就绪后立即启动，那么可以将主线程sleep 10毫秒
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

-

2.实现Runnable接口

// 通过实现Runnable接口来创建线程类
public class implementsRunnable implements Runnable
{
    private int i ;
    // run方法同样是线程执行体
    public void run()
    {
        for ( ; i < 100 ; i++ )
        {
            // 当线程类实现Runnable接口时，如果想获取当前线程，只能用Thread.currentThread()方法。
            System.out.println(Thread.currentThread().getName() + "  " + i);
        }
    }

    public static void main(String[] args)
    {
        for (int i = 0; i < 100;  i++)
        {
            System.out.println(Thread.currentThread().getName()
                    + "  " + i);
            if (i == 20)
            {
                implementsRunnable st = new implementsRunnable();

                //target是implments runnable 的类;
                //最终只会输出到100  ，两个线程运行同一个target，共享变量
                //可能会（也可能不会）线程不安全使用synchronized
                new Thread(st , "新线程1").start();
                new Thread(st , "新线程2").start();
                new Thread(st , "新线程3").start();

                try {
                    //希望 子线程在start就绪后立即启动，那么可以将主线程sleep 15毫秒
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }
    }
}

–

3.Future callable接口，允许run方法有自己的返回值

public class CallableThread {
    public static void main(String[] args)
    {
        // 创建Callable对象
        CallableThread rt = new CallableThread();
        // 先使用Lambda表达式创建Callable<Integer>对象
        // 使用FutureTask来包装Callable对象
        FutureTask<Integer> task = new FutureTask<Integer>((Callable<Integer>)() -> {
            int i = 0;
            for ( ; i < 100 ; i++ )
            {
                System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：" + i);
            }
            // call()方法可以有返回值
            return i;
        });


        for (int i = 0 ; i < 100 ; i++)
        {
            System.out.println(Thread.currentThread().getName() + " 的循环变量i的值：" + i);
            if (i == 20)
            {
                // 实质还是以Callable对象来创建、并启动线程
                //task是callable对象
                new Thread(task , "子线程").start();
                try {
                    //希望 子线程在start就绪后立即启动，那么可以将主线程sleep 10毫秒
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        try
        {
            // 获取线程返回值  task是callable对象
            //  调用get方法导致主线程阻塞
            //thread 和 runnable 就必须通过共享变量或者使用线程通信的方式在任务执行完毕之后得到任务执行结果
            System.out.println("子线程的返回值：" + task.get());
        }
        catch (Exception ex)
        {
            ex.printStackTrace();
        }
    }
}