Java线程的三种三种创建和启动

线程和进程的区别：

        操作系统多任务运行时，一个任务就是一个程序，每个运行的程序就是一个进程，内部可能包含多个顺序执行流，每个顺序执行流就是一个线程（线程在进程内可以共享进程的资源）。

      进程处于运行中的程序，进程是系统进行资源分配和调度的一个独立单位。

      特征：

         独立性：有自己的资源和地址空间。

        动态性：进程与程序的区别，程序只是一个静态的指令集合，进程是一个正在系统中活动的指令集合。

        并发性：多个进程可以在单个处理器上并发执行，互不影响。

线程（Thread）：也被称作轻量级进程，

   多线程：

                 进程之间不能内存共享，但线程之间共享内存非常容易。

                系统创建进程需要分配的系统资源多，多线程效率高。

               Java内置多线程功能支持。

线程的创建和启动：

                       1.继承Thread类创建线程类

                  // 通过继承Thread类来创建线程类

public class FirstThread extends Thread

{

    private int i ;

    // 重写run方法，run方法的方法体就是线程执行体

    public void run()

    {

        for ( ; i < 100 ; i++ )

        {

            // 当线程类继承Thread类时，直接使用this即可获取当前线程

            // Thread对象的getName()返回当前该线程的名字

            // 因此可以直接调用getName()方法返回当前线程的名

            System.out.println(getName() +  " " + i);

        }

    }

    public static void main(String[] args)

    {

        for (int i = 0; i < 100;  i++)

        {

            // 调用Thread的currentThread方法获取当前线程

            System.out.println(Thread.currentThread().getName()

                +  " " + i);

            if (i == 20)

            {

                // 创建、并启动第一条线程

                new FirstThread().start();

                // 创建、并启动第二条线程

                new FirstThread().start();

            }

        }

    }

}

       2.实现Runnable接口创建实现类

public class SecondThread 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)

            {

                SecondThread st = new SecondThread();     // ①

                // 通过new Thread(target , name)方法创建新线程

                new Thread(st , "新线程1").start();

                new Thread(st , "新线程2").start();

            }

        }

    }

}

       3.使用Callable和Future来创建线程

import java.util.concurrent.Callable;  

import java.util.concurrent.ExecutionException;  

import java.util.concurrent.FutureTask;  

 

public class CallableThreadTest implements Callable<Integer>  

{  

 

    public static void main(String[] args)  

    {  

        CallableThreadTest ctt = new Ca
4000
llableThreadTest();  

        FutureTask<Integer> ft = new FutureTask<>(ctt);  

        for(int i = 0;i < 100;i++)  

        {  

            System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  

            if(i==20)  

            {  

                new Thread(ft,"有返回值的线程").start();  

            }  

        }  

        try  

        {  

            System.out.println("子线程的返回值："+ft.get());  

        } catch (InterruptedException e)  

        {  

            e.printStackTrace();  

        } catch (ExecutionException e)  

        {  

            e.printStackTrace();  

        }  

 

    }  

 

    @Override  

    public Integer call() throws Exception  

    {  

        int i = 0;  

        for(;i<100;i++)  

        {  

            System.out.println(Thread.currentThread().getName()+" "+i);  

        }  

        return i;  

    }  

 

} 
三种方法：

实现Runnable和Callable方法基本相同

继承Thread类创建多线程

         只可以单继承，不可以继承别的类了。

         访问当前线程可以直接采用this方法。

实现Runnable和Callable接口

         线程类只是实现了，Runable和Callable接口，还可以继承其它类。

         多线程可以共享同一个Target对象，所以非常适合多个相同线程来处理统一份资源的情况，从而可以将CPU、代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。

       劣势是编程稍微复杂，访问当前线程必须采用，Thread.currentThraed()。