Java 线程01

Java 线程

 

一、线程的概念

线程，有时被称为轻量级进程(Lightweight Process，LWP），是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点儿在运行中必不可少的资源，但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程，同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约，致使线程在运行中呈现出间断性。线程也有就绪、阻塞和运行三种基本状态。就绪状态是指线程具备运行的所有条件，逻辑上可以运行，在等待处理机；运行状态是指线程占有处理机正在运行；阻塞状态是指线程在等待一个事件（如某个信号量），逻辑上不可执行。每一个程序都至少有一个线程，若程序只有一个线程，那就是程序本身。

线程是程序中一个单一的顺序控制流程。进程内一个相对独立的、可调度的执行单元，是系统独立调度和分派CPU的基本单位指运行中的程序的调度单位。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

 线程的运行模式
   A:线程的运行模式
    a:分时调度
      所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
    
    b:抢占式调度
     优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
    
     大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。


     实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
     其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

二、Java中的线程

Java中的线程可以有两种方式实现。第一种为：自定义类（class）继承Thread（线程）类。第二种为：自定义类（class）实现Runnable接口。

1. 自定义类（class）继承Thread（类）

 

   Thread类中有名为run的方法，在继承Thread类后，想要创建线程，必须重写run方法。

 

代码例子如图:

 

图片中，类MyThread继承类Thread并重写run方法。Thread.currentThread().getName()为Thread类中查看线程类名称的特有方法（具体可查看JDK）。

 

2. 自定义类（class）实现接口Runnable接口

相同的，在实现Runnable后，本类也需要重写run方法。

代码如图：

 

图为MyThread类实现接口Runnable后重写run方法创建线程。

 

线程的实现

 

如图：

 

 

在主方法中，启动一个线程是用 对象.start()实现，而不是对象.run()方法.

 

在创建对象的时候需要注意:

 对于MyThread类来说，创建一个对象a后，直接通过a.strat（）来启动线程。因为strat()为Thread类中的特有方法。正是因为如此，相对于MyThread2来说，在创建r对象后，因为MyThread类并没有继承Thread类，所以MyThread是没有strat（）方法的。所以使用r.strat（）是错误的。因此，需要用Thread  a2=new Thread（r）；的方式将对象r通过Thread的构造方法传给Thread使得a2成为Thread的对象并且具有r对象的方法。此时，便可以用a2.start（）的方法来实现另外一个线程的实现。

 

实现接口方式的好处 
    A:实现接口方式的好处
     第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。
     实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。
     继承Thread类，线程对象和线程任务耦合在一起。
     一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。
     实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
     (降低紧密性或者依赖性,创建线程和执行任务不绑定)


###18匿名内部类实现线程程序 
    *A:匿名内部类实现线程程序 
    /*
     *  使用匿名内部类,实现多线程程序
     *  前提: 继承或者接口实现
     *  new 父类或者接口(){
     *     重写抽象方法
     *  }
     */
    public class ThreadDemo {
      public static void main(String[] args) {
        //继承方式  XXX extends Thread{ public void run(){}}
        new Thread(){
          public void run(){
            System.out.println("!!!");
          }
        }.start();
        
        //实现接口方式  XXX implements Runnable{ public void run(){}}
        
        Runnable r = new Runnable(){
          public void run(){
            System.out.println("###");
          }
        };
        new Thread(r).start();
        
        
        new Thread(new Runnable(){
          public void run(){
            System.out.println("@@@");
          }
        }).start();
        
      }
    }


###20线程池的原理
   A:线程池的原理
      1.在java中，如果每个请求到达就创建一个新线程，开销是相当大的。
      2.在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。
      3.除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。
        如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。
        为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。
      线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。


JDK5实现线程池
    A:JDK5实现线程池
    /*
       *  JDK1.5新特性,实现线程池程序
       *  使用工厂类 Executors中的静态方法创建线程对象,指定线程的个数
       *   static ExecutorService newFixedThreadPool(int 个数) 返回线程池对象
       *   返回的是ExecutorService接口的实现类 (线程池对象)
       *   
       *   接口实现类对象,调用方法submit (Ruunable r) 提交线程执行任务
       *          
       */
      public class ThreadPoolDemo {
        public static void main(String[] args) {
          //调用工厂类的静态方法,创建线程池对象
          //返回线程池对象,是返回的接口
          ExecutorService es = Executors.newFixedThreadPool(2);
            //调用接口实现类对象es中的方法submit提交线程任务
          //将Runnable接口实现类对象,传递
          es.submit(new ThreadPoolRunnable());
          es.submit(new ThreadPoolRunnable());
          es.submit(new ThreadPoolRunnable());
        
        }
      }


      public class ThreadPoolRunnable implements Runnable {
        public void run(){
          System.out.println(Thread.currentThread().getName()+" 线程提交任务");
        }
      }
实现线程的Callable接口方式
  A:实现线程的Callable接口方式
     /*
      *  实现线程程序的第三个方式,实现Callable接口方式
      *  实现步骤
      *    工厂类 Executors静态方法newFixedThreadPool方法,创建线程池对象
      *    线程池对象ExecutorService接口实现类,调用方法submit提交线程任务
      *    submit(Callable c)
      */
     public class ThreadPoolDemo1 {
      public static void main(String[] args)throws Exception {
        ExecutorService es = Executors.newFixedThreadPool(2);
        //提交线程任务的方法submit方法返回 Future接口的实现类
        Future<String> f = es.submit(new ThreadPoolCallable());
        String s = f.get();
        System.out.println(s);
      }
     }
     /*
      * Callable 接口的实现类,作为线程提交任务出现
      * 使用方法返回值
      */


     import java.util.concurrent.Callable;


     public class ThreadPoolCallable implements Callable<String>{
      public String call(){
        return "abc";
      }
     }
线程实现异步计算
  A:线程实现异步计算

    /*
     * 使用多线程技术,求和
     * 两个线程,1个线程计算1+100,另一个线程计算1+200的和
     * 多线程的异步计算
     */
    public class ThreadPoolDemo {
      public static void main(String[] args)throws Exception {
        ExecutorService es = Executors.newFixedThreadPool(2);
        Future<Integer> f1 =es.submit(new GetSumCallable(100));
        Future<Integer> f2 =es.submit(new GetSumCallable(200));
        System.out.println(f1.get());
        System.out.println(f2.get());
        es.shutdown();
      }
    }

    public class GetSumCallable implements Callable<Integer>{
      private int a;
      public GetSumCallable(int a){
        this.a=a;
      }
      
      public Integer call(){
        int sum = 0 ;
        for(int i = 1 ; i <=a ; i++){
          sum = sum + i ;
        }
        return sum;
      }
    }

备注：由于个人原因，本博客暂停更新。如有问题可联系本人，本人提供技术指导、学习方向、学习路线。本人微信wlp1156107728(添加注明来意)   QQ1156107728(添加注明来意)