Java 多线程创建和线程状态

  一、进程和线程

  多任务操作系统中,每个运行的任务是操作系统运行的独立程序。

 

  为什么引进进程的概念?

  为了使得程序能并发执行,并对并发执行的程序加以描述和控制。

  因为通常的程序不能并发执行,为使程序(含数据)能独立运行,为它配置PCB——描述和和控制进程的的运行。

 

  PCB记录了了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息。

  PCB是使一个在多道程序环境下不能独立运行的程序,成为一个能独立运行的基本单位、一个能与其它进程并发执行的基本单位。

  OS是根据PCB来对并发执行的进程进行控制和管理。

  所谓创建进程,实际上是创建进程实体中的PCB;撤销进程,实质上是撤销进程的PCB。  

  

 

  程序:只是一组有序指令的集合,存放于某种介质上,本身是静态的。

  进程实体:由程序段、相关数据段和PCB组成。是动态的,有生命周期。

  进程的实质是进程实体的一次执行过程。

  进程是进程实体的运行过程,是系统进行资源分配和调度的一个独立单位。

 

  1、进程

  进程是操作系统任务调度的单位,每个任务对应一个进程。

  进程是操作系统的资源管理单位,进程包含代码和数据的地址空间以及其他的资源,比如打开的文件和信号量。不同的进程的地址空间是相互隔离的。

  应用程序在启动后会创建一个进程,系统需要为进程分配ID号和内存。

 

  2、线程介绍

  线程是比进程更小的调度单位,它依附于进程存在,多线程是在一个进程内执行多段代码序列。

  线程有自己的程序计数器、寄存器、栈等。

  引入线程的动机在于操作系统中阻塞式I/O的存在,当一个线程所执行的I/O被阻塞的时候,同一进程中的其他线程可以使用处理器执行计算,从而提高程序的执行效率。

 

  3、进程和线程比较

  为什么不使用多进程?

  进程的调度代价高,而多线程的调度代价小,更高效。

   为什么线程间通信效率高?

       进程中的多个线程共享进程的内存空间,当有新的线程产生时,操作系统不分配新的内存,而是让新线程共享原有进程块的内存。因此,线程间通信效率高。

 

  4、JVM中的进程和线程

  Java程序都运行在JVM中,每启动一个应用程序,就会启动一个JVM进程。在JVM环境中,所有的程序代码的执行都以线程实现。

       Thread类提供多线程支持,应用可以创建多个并发执行的线程。

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

  每个线程都有一个调用栈,一旦创建一个新的线程,就产生一个新的调用栈

 

  5、应用中可以创建两类线程:用户线程和守护线程。

  用户线程执行完毕时,JVM自动关闭当前程序。

  守护线程独立于JVM,守护线程一般是由操作系统或者用户自己创建的,

 

  二、创建线程

  继承Thread类,实现Runnable接口和使用Timer类。

  1、继承Thread类

  Thread类实例只是一个对象,有变量和方法,创建于堆内存上,具有生命周期,可以与其他线程对象通信并协作完成特定任务。

  线程动作放在Thread中的run()方法,它代表了线程需要完成的具体任务,因此,run()被称为线程体~

  run()不是自动执行的,为了让run()执行必须调用Thread类的start()方法,调用start()方法的目的是创建新线程并执行该线程对象的run()方法,新线程与启动它的线程将并发执行。start()方法启动后立即返回,并不等待新建线程的执行,这意味着新建线程的run()方法在调用start()方法后不一定立即执行,需要等待JVM的调度。这种多线程之间的不确定性,是并发编程的难点所在。

public class InheritThread extends Thread {
    private String name;
    public InheritThread(String name){
        this.name=name;
    }
    public void run(){
        int c=0;
        while(c<5){
            System.out.println("Greetings from thread '"+name+"'!");
            c++;
        }
    }
}

class Main {
    public static void main(String args[]) {
        InheritThread greetingsA = new InheritThread("Inherited");
        greetingsA.start();//创建新的线程
        System.out.println("Thread has been started!");

    }
}

  

  2、实现Runnable接口

  定义实现java.lang.Runnable接口的类,并实现该接口的run()方法,在run()中编写线程执行代码。

public class RunnableThread implements Runnable{
    private String name;
    public RunnableThread(String name){
        this.name=name;
    }
    public void run(){
        System.out.println("Greetings from runnable'"+name+";!");
    }
}

class Main {
    public static void main(String args[]) {
/*创建线程,需要利用RunnableThread对象生成一个Tread类的对象,然后调用start()*/
        RunnableThread greetingsB=new RunnableThread("runnable");
        Thread greetingsThread=new Thread(greetingsB);
        greetingsThread.start();
    }
}

  这种方式的好处是,任何对象都可以实现Runnable接口,从而不受Java单继承泛型的限制。run()方法能访问类中所有的变量和方法,包括私有变量和方法。这种方式的缺点是,违反了每个对象应该有一个单一的、明确的职责的原则

  

  3、使用Timer类和TimerTask类

  Timer是一种线程设施,用于安排以后在后台线程中执行的任务。可安排任务执行一次,或者定期重复执行,可以看成一个定时器,可以调度TimerTask。

  TimerTask是一个抽象类,实现了Runnable接口,所以具备了多线程的能力。

  一个Timer可以调度任意多个TimerTask,它会将TimerTask存储在一个队列中,顺序调度,如果想两个TimerTask并发执行,则需要创建两个Timer。看一个简单的例子:

import java.util.Timer;
import java.util.TimerTask;
class PaintTask extends TimerTask{
    public void run(){
        System.out.println("update");
        System.out.println("repaint");
    }
}

public class TimeDemo {
    public static void main(String args[]){
        Timer timer=new Timer();
        timer.schedule(new PaintTask(),1000,1*1000);  /*1秒后执行,周期为1秒*/
    }
}

  我们用其它方法实现同样的功能:

/*在线程的run()中执行循环,并休眠30ms,唤醒后调用更新和重绘*/
public class Animator extends Thread{
    public void run(){
        while(true){
            try{
                Thread.sleep(2000);
            }
            catch (InterruptedException e){
                System.out.println("Thread is interrupted"+e.getMessage());
            }
            updateForNextFrame();
            repaint();
        }
    }
    private void repaint(){
        System.out.println("repaint");
    }
    private void updateForNextFrame(){
        System.out.println("update");
    }
    public static void main(String args[]){
        Animator animator=new Animator();
        animator.start();//会调用run方法
        System.out.println("Thread has been started!");
    }
}

 

  三、线程状态的转换

  1、JVM的线程调度

   线程调度是指按照一定的策略为多个线程分配CPU的使用权。

  分时调度:所有线程轮流获得CPU的使用权,并平均分配占用时间。

  抢占式调度:根据线程的优先级别来获取CPU使用权,这也是JVM采用的策略。

 

  2、线程的5种状态

  新建(new)、就绪(Runnable)、运行(Running)、阻塞(Blocked)、死亡(Dead)。

  阻塞意味着等待,阻塞的线程不参与线程调度,自然不占用CPU。多线程环境下,非阻塞的线程才能被调度运行。

  新线程在start()方法被调用后就进入就绪状态,随着JVM调度的程序状态的改变在运行和就绪之间切换。遇到阻塞进入阻塞状态,当run()方法结束或发生异常线程终止执行,进入死亡状态。

 

  3、使线程离开当前运行状态的情况有三种:

  (1) 线程的run()方法执行完毕;

  (2) 在对象上调用wait()方法(不是在线程上调用);

  (3) 线程试图调用对象的方法时不能在对象上获得锁

 

  4、线程状态的转换

  线程的调度程序是JVM的一部分,JVM可以决定将当前运行状态线程切换到就绪状态,以便让另一个线程获得运行机会,而不需要任何理由。对于处于就绪状态的线程,他们被选择执行的顺序是没有保障的。对于任何一组启动的线程来说,JVM不能保证其执行次序,持续时间也不能保证。

  线程状态及转换:

 

  5、关于线程的阻塞状态

  阻塞状态是线程因为某种原因放弃了CPU使用权,暂时停止运行,直到线程进入就绪状态。

  阻塞情况分为3种:

  (1)等待阻塞:运行的线程执行了wait()方法,JVM把该线程放入等待池中。

  (2)同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池。

  (3)其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()方法状态超时、join()方法等待线程终止或超时、或者IO处理完毕时,线程重新转入就绪状态。

 

posted @ 2018-02-07 01:21  爆炸的果核  阅读(218)  评论(0编辑  收藏  举报