灵雪java15

day15

今天进行了线程的初步学习
那么什么时候该用Thread，什么时候该用Runable呢
继承Thread实现的模式是 定义多个线程,各自完成各自的任务. 实现Runnable实现的模式是 定义多个线程,实现一个任务.其实在实现一个任务用多个线程来做也可以用继承Thread类来实现只是比较麻烦，一般我们用实现Runnable接口来实现，简洁明了。大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。
3种定义方式：
1.直接定义一个子类去继承Thread类，重写run方法，
2.实现接口Rannable，重写run方法
3.匿名内部类的形式来创建
Java线程：概念与原理
一、进程与线程
进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间）。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

    线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。

    “同时”执行是人的感觉，在线程之间实际上轮换执行。

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

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

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

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

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

一个指向当前被执行指令的指令指针；
一个栈；
一个寄存器值的集合，定义了一部分描述正在执行线程的处理器状态的值
一个私有的数据区。
我们使用Join()方法挂起当前线程，直到调用Join()方法的线程执行完毕。该方法还存在包含参数的重载版本，其中的参数用于指定等待线程结束的最长时间（即超时）所花费的毫秒数。如果线程中的工作在规定的超时时段内结束，该版本的Join()方法将返回一个布尔量True。

    简而言之：

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

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

二、Java中的线程
在Java中，“线程”指两件不同的事情：

    1、java.lang.Thread类的一个实例；

    2、线程的执行。

    在 Java程序中，有两种方法创建线程：

    一是对 Thread 类进行派生并覆盖 run方法；

    二是通过实现Runnable接口创建。

    使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

    一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。

    Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。

    一个Java应用总是从main()方法开始运行，main()方法运行在一个线程内，他被称为主线程。

    一旦创建一个新的线程，就产生一个新的调用栈。

    线程总体分两类：用户线程和守候线程。

    当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。

Java线程：创建与启动
一、定义线程
1、扩展java.lang.Thread类。

    此类中有个run()方法，应该注意其用法：public void run()

    如果该线程是使用独立的Runnable运行对象构造的，则调用该Runnable对象的run方法；否则，该方法不执行任何操作并返回。

    Thread的子类应该重写该方法。

2、实现java.lang.Runnable接口。

    void run()

    使用实现接口Runnable的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的run方法。

    方法run的常规协定是，它可能执行任何所需的操作。

二、实例化线程
1、如果是扩展java.lang.Thread类的线程，则直接new即可。

    2、如果是实现了java.lang.Runnable接口的类，则用Thread的构造方法：

[java] view plain copy
Thread(Runnabletarget)
Thread(Runnabletarget, String name)
Thread(ThreadGroupgroup, Runnable target)
Thread(ThreadGroupgroup, Runnable target, String name)
Thread(ThreadGroupgroup, Runnable target, String name, long stackSize)
其中：

    Runnable target：实现了Runnable接口的类的实例。 

Thread类也实现了Runnable接口，因此，从Thread类继承的类的实例也可以作为target传入这个构造方法。
直接实现Runnable接口类的实例。
线程池建立多线程。
String name：线程的名子。这个名子可以在建立Thread实例后通过Thread类的setName方法设置。默认线程名：Thread-N，N是线程建立的顺序，是一个不重复的正整数。

    ThreadGroup group：当前建立的线程所属的线程组。如果不指定线程组，所有的线程都被加到一个默认的线程组中。

    long stackSize：线程栈的大小，这个值一般是CPU页面的整数倍。如x86的页面大小是4KB.在x86平台下，默认的线程栈大小是12KB。

三、启动线程
在线程的Thread对象上调用start()方法，而不是run()或者别的方法。

    在调用start()方法之前：线程处于新状态中，新状态指有一个Thread对象，但还没有一个真正的线程。

    在调用start()方法之后：发生了一系列复杂的事情——

    启动新的执行线程（具有新的调用栈）；

    该线程从新状态转移到可运行状态；

    当该线程获得机会执行时，其目标run()方法将运行。

    注意：对Java来说，run()方法没有任何特别之处。像main()方法一样，它只是新线程知道调用的方法名称（和签名）。因此，在Runnable上或者Thread上调用run方法是合法的。但并不启动新的线程。

四、例子
1、实现Runnable接口的多线程例子

[java] view plain copy
/**

• 实现Runnable接口的类
  */
  public class RunnableImpl implements Runnable{
  private Stringname;
  public RunnableImpl(String name) {
  this.name = name;
  }
  @Override
  public void run() {
  for (int i = 0; i < 5; i++) {
  for(long k=0;k<100000000;k++);
  System.out.println(name+":"+i);
  }
  }
  }

/**

• 测试Runnable类实现的多线程程序
  */
  public class TestRunnable {

  public static void main(String[] args) {
  RunnableImpl ri1=new RunnableImpl(“李白”);
  RunnableImpl ri2=new RunnableImpl(“屈原”);
  Thread t1=new Thread(ri1);
  Thread t2=new Thread(ri2);
  t1.start();
  t2.start();
  }
  }

   执行结果：
  

[java] view plain copy
屈原:0
李白:0
屈原:1
李白:1
屈原:2
李白:2
李白:3
屈原:3
李白:4
屈原:4
2、扩展Thread类实现的多线程例子

[java] view plain copy
/**

• 测试扩展Thread类实现的多线程程序
  */
  public class TestThread extends Thread {
  public TestThread(String name){
  super(name);
  }
  @Override
  public void run() {
  for(int i=0;i<5;i++){
  for(long k=0;k<100000000;k++);
  System.out.println(this.getName()+":"+i);
  }
  }
  public static void main(String[] args){
  Thread t1=new TestThread(“李白”);
  Thread t2=new TestThread(“屈原”);
  t1.start();
  t2.start();
  }
  }
  执行结果：
  [java] view plain copy
  屈原:0
  李白:0
  屈原:1
  李白:1
  屈原:2
  李白:2
  屈原:3
  屈原:4
  李白:3
  李白:4
  对于上面的多线程程序代码来说，输出的结果是不确定的。其中的一条语句for(long k=0;k<100000000;k++);是用来模拟一个非常耗时的操作的。

五、一些常见问题
1、线程的名字，一个运行中的线程总是有名字的，名字有两个来源，一个是虚拟机自己给的名字，一个是你自己的定的名字。在没有指定线程名字的情况下，虚拟机总会为线程指定名字，并且主线程的名字总是mian，非主线程的名字不确定。

    2、线程都可以设置名字，也可以获取线程的名字，连主线程也不例外。

    3、获取当前线程的对象的方法是：Thread.currentThread()；

    4、在上面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。

    5、当线程目标run()方法结束时该线程完成。

    6、一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。一个可运行的线程或死线程可以被重新启动。

    7、线程的调度是JVM的一部分，在一个CPU的机器上上，实际上一次只能运行一个线程。一次只有一个线程栈执行。JVM线程调度程序决定实际运行哪个处于可运行状态的线程。

    众多可运行线程中的某一个会被选中做为当前线程。可运行线程被选择运行的顺序是没有保障的。

    8、尽管通常采用队列形式，但这是没有保障的。队列形式是指当一个线程完成“一轮”时，它移到可运行队列的尾部等待，直到它最终排队到该队列的前端为止，它才能被再次选中。事实上，我们把它称为可运行池而不是一个可运行队列，目的是帮助认识线程并不都是以某种有保障的顺序排列而成一个一个队列的事实。

    9、尽管我们没有无法控制线程调度程序，但可以通过别的方式来影响线程调度的方式