理论总复习

理论总复习

线程总复习
创建 线程方式
          (1)继承Thread(2)实现Runnable
            注意:  在类中要重写run()方法
启动线程
           第一种直可以实例化线程类用start()启动
         
第二种也要实例线程类。之后在构建一个Thread实例,将线程实例名作为Thread的参数
          
参考实例:
 Thread的相关方法
      isDaemon()测试该线程是否为守护线程(后台线程)
      setDaemont()设置为守护线程线程
                                     
后台线程:当主线或用户线程执行完了之后,后台线程也自动结束(缺省是用户线程)
                                       参考实例:

      currentThread()返回对当前正在执行的线程对象的引用。
      activeCount() 返回当前线程的线程组中活动线程的数目。
      int enumerate(Thread[] tarray)
将当前线程的线程组及其子组中的每一个活动线程复制到指定的数组中。
                                         参考实例:

 线程的生命周期
                 创建(start)————>就绪–>执行(run)–>结束
               
创建–>就绪————>执行–>堵塞——>就绪————>执行结束
 线程优先级
      
1最低,10最高,默认的是5;高优先级的线程运行完了之后,才能轮到下一级线程执行(开发中不提倡这种控制)
                 子线程的优先级和父类的优先级一样
      getPriority() 返回线程的优先级。
      setPriority(int newPriority) 更改线程的优先级。
线程的串行化
    
在多线程中,如果在一个线程运行的过程中要用到另一个纯种的运行结果,则可进行进行的串型化处理
       join()等待该线程终止。
       join(long millis)  等待该线程终止的时间最长为 millis 毫秒。
       join(long millis, int nanos) 等待该线程终止的时间最长为 millis
毫秒 + nanos 纳秒
                 
参考实例:
线程让步
                
让运行中线程主动放弃当前获得的CPU处理机会,但不是使该纯种阻塞,而是使之转为就绪
       yield()  暂停当前正在执行的线程对象,并执行其他线程。
                  
参考实例:
线程的挂起和恢复
                 
挂起:暂时停止当前运行中的线程,使之转入阻塞状态,并且不会自动恢复运行
               恢复:使得一个已挂起的纯种恢复运行
         suspend()让一个线程挂起(现已过时)
        resume() 恢复一个挂起纯种(现已过时)
                   参考实例:

 互斥锁
          来保共享数据操作的完整性
         
每个对象都对应一个互斥锁的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象
         关键字
synchronized来与对象的互斥锁联系,在某个对象用synchronized修饰
       synchronized在方法的应用(同步方法)
       synchronized(Object)在方法中的应用(同步语句步)
          参考实例:

  线程的死锁
           并发运行的多个线程问彼此等待,都无法运行的状态
        参考实例:

线程同步通信
    
为了在线程进入阻塞状态时应尽量释放其锁定的资源,以为其他的线程提供运行的机会
澳门新葡亰游戏网址,     wait()让当前阻塞
     notify()唤醒阻塞的一个线程
     notifyAll() 唤醒所有阻塞的线程
         
参考实例
   

一、进程

  进程是操作系统结构的基础;是一次程序的执行;是一个程序及其数据在处理机上顺序执行时所发生的活动。操作系统中,几乎所有运行中的任务对应一条进程(Process)。一个程序进入内存运行,即变成一个进程。进程是处于运行过程中的程序,并且具有一定独立功能。描述进程的有一句话非常经典——进程是系统进行资源分配和调度的一个独立单位。

  进程是系统中独立存在的实体,拥有自己独立的资源,拥有自己私有的地址空间进程的实质,就是程序在多道程序系统中的一次执行过程,它是动态产生,动态消亡的,具有自己的生命周期和各种不同的状态。进程具有并发性,它可以同其他进程一起并发执行,按各自独立的、不可预知的速度向前推进。 

(注意,并发性(concurrency)和并行性(parallel)是不同的。并行指的是同一时刻,多个指令在多台处理器上同时运行。并发指的是同一时刻只能有一条指令执行,但多个进程指令被被快速轮换执行,看起来就好像多个指令同时执行一样。)

  进程由程序数据进程控制块三部分组成。

 

 

二、线程

  线程,有时被称为轻量级进程(Lightweight
Process,LWP),是程序执行流的最小单元。一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成。另外,线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源。一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行。由于线程之间的相互制约,致使线程在运行中呈现出间断性。每一个程序都至少有一个线程,若程序只有一个线程,那就是程序本身。

  线程是程序中一个单一的顺序控制流程。在单个程序中同时运行多个线程完成不同的工作,称为多线程。

    在Java
Web中要注意,线程是JVM级别的,在不停止的情况下,跟JVM共同消亡,就是说如果一个Web服务启动了多个Web应用,某个Web应用启动了某个线
程,如果关闭这个Web应用,线程并不会关闭,因为JVM还在运行,所以别忘了设置Web应用关闭时停止线程。

 

三、线程状态  

   澳门新葡亰游戏网址 1

 

(图片出处:

 线程共包括以下5种状态。

  1. 新建状态(New)         :
    线程对象被创建后,就进入了新建状态。此时它和其他Java对象一样,仅仅由Java虚拟机分配了内存,并初始化其成员变量值。

  2. 就绪状态(Runnable):
    也被称为“可执行状态”。线程对象被调用了该对象的start()方法,该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器。处于就绪状态的线程,随时可能被CPU调度执行,取决于JVM中线程调度器的调度。

  3. 运行状态(Running) :
    线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态。

  4. 阻塞状态(Blocked)  :
    阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
        (01) 等待阻塞 —
    通过调用线程的wait()方法,让线程等待某工作的完成。
        (02) 同步阻塞 —
    线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。
        (03) 其他阻塞 —
    通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

  5. 死亡状态(Dead)    :
    线程执行完了、因异常退出了run()方法或者直接调用该线程的stop()方法(容易导致死锁,现在已经不推荐使用),该线程结束生命周期。

 

 

四、wait()、notify()、nofityAll()方法 

  在Object.java中,定义了wait(), notify()和notifyAll()等方法。

  wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁

  而
notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

Object类中关于等待/唤醒的API详细信息如下:
  notify()        —
唤醒在此对象监视器上等待的单个线程,使其进入“就绪状态”。  
  notifyAll()   —
唤醒在此对象监视器上等待的所有线程,使其进入“就绪状态”。
  wait()                                     —
让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify()
方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)。
  wait(long timeout)                 —
让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify()
方法或 notifyAll()
方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。
  wait(long timeout, int nanos) —
让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify()
方法或 notifyAll()
方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量”,当前线程被唤醒(进入“就绪状态”)。

 wait()的作用是让“当前线程”等待(会释放锁),而“当前线程”是指正在cpu上运行的线程!

 此处,

 

 

五、yield()、sleep()、join()和interrupt()方法  

1、yield() 

  yield()是Thread类的静态方法。它能让当前线程暂停,但不会阻塞该线程,而是由“运行状态”进入到“就绪状态”,从而让
其它具有相同优先级的等待线程获取执行权;但是,并不能保证在当前线程调用yield()之后,其它具有相同优先级的线程就一定能获得执行权;也有可能是
当前线程又进入到“运行状态”继续运行!

  值得注意的是,yield()方法不会释放锁

 

2、sleep()

  sleep()是Thread类的静态方法。该方法声明抛出了InterrupedException异常。所以使用时,要么捕捉,要么声明抛出。

  有2种重载方式:

——static void sleep(long
millis)  :  让当前正在执行的线程暂停millis毫秒,并进入阻塞状态,该方法受到系统计时器和线程调度器的精度和准度的影响。

——static void sleep(long millis , int
nanos)  :  让当前正在执行的线程暂停millis毫秒加nanos微秒,并进入阻塞状态,该方法受到系统计时器和线程调度器的精度和准度的影响。

  sleep()
的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,从而等待cpu的调度执行。常用来暂停程序的运行。  

  同时注意,sleep()方法不会释放锁

 

3、join()

  join()
是Thread的一个实例方法。表示,当某个程序执行流中调用其他线程的join方法时,调用线程将被阻塞,直到被join的线程执行完毕。

有3种重载的形式:

网站地图xml地图