Java多线程知识整理

一、进程的概念

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

二、线程的概念

线程是程序执行流的最小单元，是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。

三、我的理解

进程就是系统运行了一个程序，线程是进程中的一段代码块。

一个进程可以包含多个线程，这些线程可以并发执行，就为多线程。

四、Thread类

   public class Thread extends Object implements Runnable

   实现多线程的方式一：定义一个类，继承Thread类，重写run()方法。

   在内存中，run()方法会运行在新线程的栈区中。

   例：

public class ThreadDemo extends Thread {

    //重写run方法
    @Override
    public void run() {
       for(int i = 0; i < 20; i++){
           System.out.println("我是run方法"+i);
       }
    }
}
class ThreadTest{
    public static void main(String[] args){
        //因为Thread是线程类，ThreadDemo是其子类，所以这是开启新的线程对象，从主线程中开启新的执行路径
        ThreadDemo td = new ThreadDemo();
        //调用start()方法，启动线程，然后会让虚拟机调用重写后的run()方法
        td.start();
        for(int i = 0; i < 20; i++){
            System.out.println("我是main方法"+i);
        }
    }
}

   每个线程都有自己的名字，运行main方法主线程，其线程名称为main，其它线程的名称默认为Thread-0,Thread-1,……。

五、Runnable接口

   public interface Runnable

   实现多线程的方式二：定义一个类，实现Runnable接口，实现run()方法。

   例：

public class ThreadDemo_2 implements Runnable{
    
    @Override
    public void run() {
        for(int i = 0; i < 20; i++){
            System.out.println("我是run方法"+i);
        }
    }
}
class ThreadTest_2{
    public static void main(String[] args){
        //创建线程对象
        ThreadDemo_2 td = new ThreadDemo_2();
        //开启线程，因为start()方法是在Thread类中定义的，所以要创建Thread对象，将线程对象当参数传递，然后调用start()方法
        Thread t = new Thread(td);  //可以简写为：new Thread(td).start();
        t.start();
        for(int i = 0; i < 20; i++){
            System.out.println("我是main方法"+i);
        }
    }
}

实现接口的好处：类可以实现多个接口，避免了单继承的局限性。同时降低了程序的耦合性。

六、匿名内部类实现多线程

   例：

 

  public class ThreadDemo_3 {

    //匿名内部类实现多线程
    public static void main(String[] args){
        //方式一
        new Thread(){
            @Override
            public void run() {
                System.out.println("新线程_01");
            }
        }.start();

        //方式二
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程_02");
            }
        };
        new Thread(r).start();

        //方式三
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程_03");
            }
        }).start();
    }

}

七、线程的状态

   1.new：至今尚未启动的线程所处的状态。(新建状态) 创建Thread类对象或其子类对象，会进入此状态。

   2.runnable：正在Java虚拟机中执行的线程处于这种状态。(可运行状态) 调用start()方法后，会进入此状态。(不能再变成新建状态)

   3.blocked：受阻塞并等待某个监视器锁的线程的状态。(阻塞状态)

   4.waiting：无限的等待另一个线程来执行某一特定操作的线程的状态。(休眠状态)

   5.timed_waiting：等待另一个线程来执行取决于指定等待时间的操作的线程的状态。(等待状态)

   6.terminated：已退出的线程所处的状态。(死亡状态) run()方法运行结束或调用stop()方法(已过时)会进入此状态。

八、线程池

   JDK1.5新特性：线程池

   public class Executors extends Object

  使用上述工厂类的静态方法static ExecutorService   newFixedThreadPool(int nThreads)，创建线程池对象。参数用于指定线程的个数。返回ExecutorService接口的实现类(线程池对象)，调用方法submit(Runnable task),提交线程执行的任务。该方法返回返回一个表示该任务的 Future。

例：

public class ThreadPoolDemo {

    public static void main(String[] args){
        //调用工厂的静态方法，创建线程池对象
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //调用submit方法，提交任务，它会自己调用run()方法
        executorService.submit(new ThreadPoolTest());
        //executorService.shutdown();   //销毁线程池
        for(int i = 0; i < 20; i++){
            System.out.println("我是main方法"+i);
        }
    }

}
class ThreadPoolTest implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 20; i++){
            System.out.println("我是run方法"+i);
        }
    }
}

九、Callable接口

public interface Callable<V>

实现多线程的方式三：实现Callable接口，重写call()方法。该方法有返回值，而run()方法没有。

Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。

例：
 

public class ThreadDemo_4 {

    public static void main(String[] args) throws Exception {
        //调用工厂的静态方法，创建线程池对象
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //调用submit方法，提交任务，它会自己调用run()方法，返回Future接口实现类
        Future<Integer> future = executorService.submit(new CallableTest());
        //使用get()方法获取返回值
        Integer i = future.get();
        System.out.println("线程的运算结果为："+i);

    }
}
class CallableTest implements Callable{

    @Override

    //此方法返回值为泛型 V ，所以可以返回任意对象的类型
    public Integer call() throws Exception {
        int a = 10+20;
        return a;
    }
}