java线程介绍和应用

java-线程介绍和应用

1.概念

1. 程序，进程，线程的概念

   程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码。

   进程就是正在执行的程序，是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间）。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

   线程是指进程中的一个执行流程，是一个进程内部的最小执行单元（执行任务），一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，线程没有主机的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

2. 进程和线程的关系

   进程在执行过程中拥有独立的内存单元，进程有独立的地址空间，而多个线程共享内存，从而极大地提高了程序的运行效率。

   线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

   进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位。

   线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器,一组寄存器和栈），但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源。

   线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程包含以下内容：

   • 一个指向当前被执行指令的指令指针；
   • 一个栈；
   • 一个寄存器值的集合，定义了一部分描述正在执行线程的处理器状态的值
   • 一个私有的数据区。

   我们使用Join()方法挂起当前线程，直到调用Join()方法的线程执行完毕。该方法还存在包含参数的重载版本，其中的参数用于指定等待线程结束的最长时间（即超时）所花费的毫秒数。如果线程中的工作在规定的超时时段内结束，该版本的Join()方法将返回一个布尔量True。

   简而言之：

   • 一个程序至少有一个进程，一个进程至少有一个线程。
   • 线程的划分尺度小于进程，使得多进程程序的并发性高。
   • 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
   • 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
   • 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

   在Java中，每次程序运行至少启动2个线程：一个是main线程，一个是垃圾收集线程。因为每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启动了一个进程。

3. 多线程的概念

   多线程是指程序中包含多个执行单元，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。

   多线程是指一个进程在执行过程中可以产生多个更小的程序单元，这些更小的单元称为线程，这些线程可以同时存在，同时运行，一个进程可能包含多个同时执行的线程。

   好处：

   1. 提高程序的响应。
   2. 提高CPU的利用率
   3. 改善程序结构，将复杂任务分为多个线程，独立运行。

   坏处：

   1. 线程也是程序，所以线程需要占用内存，线程越多占用内存也越多。
   2. 多线程需要协调和管理，所以需要CPU时间跟踪线程。
   3. 线程之间对共享资源的访问会相互影响，必须解决竞用共享资源的问题。

   何时需要：

   1. 程序需要同时执行两个或多个任务。
   2. 程序需要实现一些需要等待的任务是，如用户输入、文件读写操作、网络操作、搜索等。
   3. 需要一些后台运行的程序时。

2.线程的创建

1. 继承Thread类的方式

   public class Main {
        
   
   
       public static void main(String[] args) {
        
           /*
              在main主线程中创建一个独立的线程,并启动运行这个线程
           */
           ThreadDemo1 t= new ThreadDemo1();
           //t.run(); 调用方法就不是启动新的线程,而就是一个普通方法调用
           t.start();//启动一个线程  CPU可以加载执行,与main线程有相同执行权,交替执行
           for (int i = 0; i < 10000; i++) {
        
               System.out.println("Main:"+i);
           }
           ThreadDemo2 t2 = new ThreadDemo2();
           t2.start();
       }
   }
   

   /*
     线程类
     方式1:继承Thread类 重写run方法
    */
   public class ThreadDemo1 extends Thread{
        
       /*
          在run方法中编写需要独立运行的代码
        */
       @Override
       public void run() {
        
           for (int i = 0; i < 10000; i++) {
        
               System.out.println("ThreadDemo1:"+i );
           }
       }
   }
   

2. 实现Runnable接口方式

   主要为了解决java中不允许多继承的问题

   public class Main {
        
       public static void main(String[] args) {
        
           RunnableDemo r = new RunnableDemo();
           Thread t = new Thread(r);
           t.start();
           Thread t1 = new Thread(r);//两个线程同一对象
           t1.start();
       }
   }
   

   /*
     线程类
     方式2:实现Runnable类 重写run方法
    */
   public class RunnableDemo implements Runnable{
        
       @Override
       public void run() {
        
           for (int i = 0; i < 1000; i++) {
        
               System.out.println("RunnableDemo:"+i);
           }
       }
   }
   

3. 两者的联系与区别

   1. 区别

      继承Thread:线程代码存放Thread子类run方法中

      实现Runnable:线程代码存在接口的子类的run方法中

   2. 实现Runnable的好处

      避免了单继承的局限性

      多个线程可以共享同一接口实现类的对象,非常适合多个相同线程来处理同一份资源

4. 实现Callable接口方式

   与Runnable相比：

   1. 相比run（）方法，可以有返回值
   2. 方法可以抛出异常
   3. 支持泛型的返回值
   4. 需要借助FutureTask类，获取返回值

   import java.util.concurrent.Callable;
   /*
        实现Callable接口 重写call（）  可以抛出异常，可以有返回值
    */
   public class CallableDemo implements Callable<Integer> {
        
       int num = 0;
       @Override
       public Integer call() throws Exception {
        
           for (int i = 0; i < 10; i++) {
        
               nu