Java总结(九)——(线程模块 一(线程的创建(方法一)与启动,线程状态与生命周期,进程与线程))

一.进程与线程

  1. 进程:每一个独立运行的程序称为一个进程
  2. 线程:线程时一个进程内部的一条执行路径,Java虚拟机允许程序并发的运行多个执行路径

    *进程中执行运算的最小单位——>线程<——处理机分配

  3. 进程与线程的区别:

    (1)进程有独立的运行地址空间,一个进程崩溃后不会影响到其他的进程,而线程只是 一个进程中的一个执行路径,如果有一条线程奔溃了,可能会影响到进程中的的其他线程

    (2)线程有自己的栈和局部变量,多个线程共享同一进程的地址空间

    (3)一个进程至少有一个线程

  4. 多线程

    (1)多线程 就是在一个进程中创建多个线程,每个线程完成一个任务

    (2)优点:

    <1>多线程技术使程序的响应速度更快

    <2>提高资源利用率

    <3>程序设计更加简单

  5. 多线程的执行特性

    (1)随机性(一部执行):谁“抢”到CPU,谁执行

    (2)宏观上同时执行,微观上同一时刻只能执行一个线程(多核除外)

    二.线程的创建和启动

    1.两种创建 新线程的方式

    <1>第一种方式:将类声明为Thread的子类并重写run()方法

    格式:

    class MygThread extends Thread{

    Public void run(){

    线程具体执行代码

    }

    }

    创建此线程类的实例并启动:

    MyThread thread1=new MyThread()

    Thread1.start();  //启动线程

    2.线程的基本使用方法

    (1)public void start():是该线程开始执行

    (2)public static Thread currentThread(): 返回对当前正在执行的线程对象的引用

    (3)public final void seetName(String str):改变线程名称

    (4)public final void setDDeamon(boolean  on):将该线程标记为守护线程或用户线程

    (5)public static void sleep(long millis):线程休眠指定毫秒数

    (6)public final void join():当前线程必须等待,直到调用join()方法的线程对象所对应的线程运行完毕,当前线程才恢复执行

    (7)public static void yield():线程礼让,但操作系统可以忽略这个礼让请求

    例1(以创建线程为例):

    创建线程:

    package thread;

    public class ThreadDemo extends Thread {

        public ThreadDemo() {

    }

        public ThreadDemo(String name) {

            super(name);

    }

    @Override

        public void run() {

            for (int i = 0; i < 10; i++) {

    System.out.println(Thread.currentThread().getName()+"循环输出i="+i);

    }

        super.run();

    }

    }

    实例化线程测试:

    package thread;

    public class ThreadTest {

        public static void main(String[] args) {

    ThreadDemo thread=new ThreadDemo("线程A——>");

    thread.start();

    ThreadDemo thread1=new ThreadDemo("线程B——>");

    thread1.start();

    }

    }

    运行结果:

    线程A——>循环输出i=0

    线程B——>循环输出i=0

    线程A——>循环输出i=1

    线程A——>循环输出i=2

    线程A——>循环输出i=3

    线程B——>循环输出i=1

    线程A——>循环输出i=4

    线程B——>循环输出i=2

    线程B——>循环输出i=3

    线程A——>循环输出i=5

    线程B——>循环输出i=4

    线程A——>循环输出i=6

    线程B——>循环输出i=5

    线程A——>循环输出i=7

    线程B——>循环输出i=6

    线程A——>循环输出i=8

    线程B——>循环输出i=7

    线程B——>循环输出i=8

    线程A——>循环输出i=9

    线程B——>循环输出i=9

    例2(以线程中的休眠方法为例):

    创建线程:

    package thread;

    public class ThreadDemo extends Thread {

    public ThreadDemo() {

    }

    public ThreadDemo(String name) {

    super(name);

    }

    @Override

    public void run() {

    for (int i = 0; i < 10; i++) {

    System.out.println(Thread.currentThread().getName()+"循环输出i="+i);

    }

    super.run();

    }

    }

    测试休眠方法:

    package thread;

    public class ThreadTest {

    public static void main(String[] args) {

    ThreadDemo thread=new ThreadDemo("线程A——>");

    thread.start();

    ThreadDemo thread1=new ThreadDemo("线程B——>");

    thread1.start();

    for (int i = 0; i < 10; i++) {

    try {

    Thread.sleep(1000);//当前线程休眠1000ms

    } catch (InterruptedException e) {

    System.out.println("捕获到的已常为:"+e.getMessage());

    }

    System.out.println(Thread.currentThread().getName()+"线程——>i="+i);

    }

    }

    }

    运行结果:

    线程A——>循环输出i=0

    线程A——>循环输出i=1

    线程A——>循环输出i=2

    线程A——>循环输出i=3

    线程A——>循环输出i=4

    线程A——>循环输出i=5

    线程A——>循环输出i=6

    线程A——>循环输出i=7

    线程A——>循环输出i=8

    线程A——>循环输出i=9

    main线程——>i=0

    main线程——>i=1

    main线程——>i=2

    main线程——>i=3

    main线程——>i=4

    main线程——>i=5

    main线程——>i=6

    main线程——>i=7

    main线程——>i=8

    main线程——>i=9

    当前线程运行所用时间:10s

    例3(以线程中的join方法为例):

    创建线程类:

    package thread;

    public class ThreadDemo extends Thread {

    public ThreadDemo() {

    }

    public ThreadDemo(String name) {

    super(name);

    }

    @Override

    public void run() {

    for (int i = 0; i < 20; i++) {

    System.out.println(Thread.currentThread().getName()+"循环输出i="+i);

    }

    super.run();

    }

    }

    测试join()方法类:

    package thread;

    public class ThreadModth {

    public static void main(String[] args){

    ThreadDemo thread=new ThreadDemo("线程一——>");

    thread.start();

    for (int i = 1; i < 20; i++) {

    if(i==10){

    try {

    thread.join();//当前线程休眠, 直到调用join方法的线程 执行完毕,当前线程开始执行

    } catch (InterruptedException e) {

    System.out.println("捕获到的异常为:"+e.getMessage());

    }

    }

    System.out.println(Thread.currentThread().getName()+"线程——>i="+i);

    }

    }

    }

    运行结果:

    main线程——>i=1

    main线程——>i=2

    线程一——>循环输出i=0

    main线程——>i=3

    线程一——>循环输出i=1

    main线程——>i=4

    线程一——>循环输出i=2

    main线程——>i=5

    线程一——>循环输出i=3

    main线程——>i=6

    线程一——>循环输出i=4

    main线程——>i=7

    线程一——>循环输出i=5

    main线程——>i=8

    线程一——>循环输出i=6

    main线程——>i=9

    线程一——>循环输出i=7

    线程一——>循环输出i=8

    线程一——>循环输出i=9

    线程一——>循环输出i=10

    线程一——>循环输出i=11

    线程一——>循环输出i=12

    线程一——>循环输出i=13

    线程一——>循环输出i=14

    线程一——>循环输出i=15

    线程一——>循环输出i=16

    线程一——>循环输出i=17

    线程一——>循环输出i=18

    线程一——>循环输出i=19

    main线程——>i=10

    main线程——>i=11

    main线程——>i=12

    main线程——>i=13

    main线程——>i=14

    main线程——>i=15

    main线程——>i=16

    main线程——>i=17

    main线程——>i=18

    main线程——>i=19

    二.线程的生命周期(状态转换)

    1.线程的状态

    2.要想实现多线程,必须在主线程中创建新的线程对象,任何线程都具有五种状态:创建,就绪,运行,阻塞,终止

    状态图:

    3.线程的停止

    (1)如果线程的run()方法中执行的是一个重复执行的循环,可以提供一个标记来控制循环是否执行吧

    (2)如果线程因为执行sleep()方法或是wait()方法而进入了阻塞状态,此时想要停止它,可以使用interrupt(),程序会抛出InterruptException异常

    (3)如果程序因为输入输出的等待而阻塞,基本上 必须等待输入输出动作完成后才能离开阻塞状态,无法用interrupt() 方法来使线程离开run()方法,要想离开,只能通过引发一个异常

    例1.(停止循环线程)

    创建循环线程:

    package stopthread;

    public class LoopThread extends Thread{

    private boolean flag=true;//设置线程停止标志

    public void setFlag(boolean flag) {

    this.flag = flag;

    }

    @Override

    public void run() {

    while(flag){

    System.out.println("当前 线程正在运行....");

    }

    }

    }

    测试停止循环线程:

    package stopthread;

    public class StopLoop {

    public static void main(String[] args) {

    long startTime= System.currentTimeMillis();//开始线程时间

    LoopThread lt=new LoopThread();

    lt.start();

    try {

    Thread.sleep(3000);//当前线程休眠3000ms

    } catch (InterruptedException e) {

    System.out.println("捕获到的异常为:"+e.getMessage());

    }

    lt.setFlag(false);

    System.out.println("end............");

    long destTime=System.currentTimeMillis();//结束线程时间

    System.out.println("执行完线程共用时间:"+(destTime-startTime)/1000+"s");

    }

    }

    运行结果:

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    当前 线程正在运行....

    ...................

    ...................

    end............

    执行完线程共用时间:3s

    例2.(以中断休眠为例 )

    创建休眠中断线程:

    package stopthread;

    public class InterruptThread extends Thread{

    private String name;

    public InterruptThread(String name) {

    super(name);

    this.name = name;

    }

    @Override

    public void run() {

    System.out.println(Thread.currentThread().getName()+"开始执行");

    System.out.println("准备休息5s");

    long startTime=System.currentTimeMillis();// 线程开始时间

    try {

    Thread.sleep(5000);

    } catch (InterruptedException e) {

    System.out.println("为什么要叫醒我?");

    }

    long destTime=System.currentTimeMillis();//线程完毕时间

    System.out.println(Thread.currentThread().getName()+"执行完毕");

    System.out.println("执行线程所用时间:"+(destTime-startTime)/1000+"s");

    }

    }

    测试终端休眠:

    package stopthread;

    public class StopInterrupt {

    public static void main(String[] args) {

    InterruptThread it=new InterruptThread("线程一——>");

    it.start();

    try {

    Thread.sleep(2000);//当前线程休眠2000ms

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    it.interrupt();//打断这个线程,使之抛出InterruptedException异常

    }

    }

    运行结果:

    线程一——>开始执行

    准备休息5s

    为什么要叫醒我?

    线程一——>执行完毕

    执行线程所用时间:2s

原文地址:http://blog.51cto.com/13501268/2071897

时间: 2024-10-10 12:36:52

Java总结(九)——(线程模块 一(线程的创建(方法一)与启动,线程状态与生命周期,进程与线程))的相关文章

[原创]java WEB学习笔记94:Hibernate学习之路---session 的管理,Session 对象的生命周期与本地线程绑定

本博客的目的:①总结自己的学习过程,相当于学习笔记 ②将自己的经验分享给大家,相互学习,互相交流,不可商用 内容难免出现问题,欢迎指正,交流,探讨,可以留言,也可以通过以下方式联系. 本人互联网技术爱好者,互联网技术发烧友 微博:伊直都在0221 QQ:951226918 -----------------------------------------------------------------------------------------------------------------

Java 对象锁-synchronized()与线程的状态与生命周期

synchronized(someObject){ //对象锁 } 对象锁的使用说明: 1.对象锁的返还. 当synchronize()语句执行完成. 当synchronize()语句执行出现异常. 当线程调用了wait()方法. 2.使用对象锁保护的数据都必须是私有的. 3.对象锁具有可重入性. 一个线程在已经获得对象锁的情况下,可以再次请求获得对象锁. 4.线程的生命周期

线程的生命周期以及控制线程

一.线程的生命周期 线程状态转换图: 1.新建状态 用new关键字和Thread类或其子类建立一个线程对象后,该线程对象就处于新生状态.处于新生状态的线程有自己的内存空间,通过调用start方法进入就绪状态(runnable). 注意:不能对已经启动的线程再次调用start()方法,否则会出现java.lang.IllegalThreadStateException异常. 2.就绪状态 处于就绪状态的线程已经具备了运行条件,但还没有分配到CPU,处于线程就绪队列(尽管是采用队列形式,事实上,把它

线程的状态和生命周期

http://blog.csdn.net/lonelyroamer/article/details/7949969 线程的状态转换: 1.新建状态用new Thread()建立一个线程对象后,该线程对象就处于新生状态. 2.就绪状态通过调用线程的start方法进入就绪状态(runnable).注意:不能对已经启动的线程再次调用start()方法,否则会出现Java.lang.IllegalThreadStateException异常.处于就绪状态的线程已经具备了运行条件,但还没有分配到CPU,处

iOS多线程全套:线程生命周期,多线程的四种解决方案,线程安全问题,GCD的使用,NSOperation的使用

目的 本文主要是分享iOS多线程的相关内容,为了更系统的讲解,将分为以下7个方面来展开描述. 多线程的基本概念 线程的状态与生命周期 多线程的四种解决方案:pthread,NSThread,GCD,NSOperation 线程安全问题 NSThread的使用 GCD的理解与使用 NSOperation的理解与使用 Demo在这里:WHMultiThreadDemo Demo的运行gif图如下: 一.多线程的基本概念 进程:可以理解成一个运行中的应用程序,是系统进行资源分配和调度的基本单位,是操作

Java中的进程和线程

 Java中的进程与线程 一:进程与线程 概述:几乎任何的操作系统都支持运行多个任务,通常一个任务就是一个程序,而一个程序就是一个进程.当一个进程运行时,内部可能包括多个顺序执行流,每个顺序执行流就是一个线程. 进程:进程是指处于运行过程中的程序,并且具有一定的独立功能.进程是系统进行资源分配和调度的一个单位.当程序进入内存运行时,即为进程. 进程的三个特点: 1:独立性:进程是系统中独立存在的实体,它可以独立拥有资源,每一个进程都有自己独立的地址空间,没有进程本身的运行,用户进程不可以直接访问

Java中的进程与线程(总结篇)

详细文档: Java中的进程与线程.rar 474KB 1/7/2017 6:21:15 PM 概述: 几乎任何的操作系统都支持运行多个任务,通常一个任务就是一个程序,而一个程序就是一个进程.当一个进程运行时,内部可能包括多个顺序执行流,每个顺序执行流就是一个线程. 进程与线程: 进程是指处于运行过程中的程序,并且具有一定的独立功能.进程是系统进行资源分配和调度的一个单位.当程序进入内存运行时,即为线程. 进程拥有以下三个特点: 1:独立性:进程是系统中独立存在的实体,它可以独立拥有资源,每一个

Java 多线程(三) 线程的生命周期及优先级

Java 多线程(三) 线程的生命周期及优先级 线程的生命周期 线程的生命周期:一个线程从创建到消亡的过程. 如下图,表示线程生命周期中的各个状态: 线程的生命周期可以分为四个状态: 1.创建状态: 当用new操作符创建一个新的线程对象时,该线程处于创建状态. 处于创建状态的线程只是一个空的线程对象,系统不为它分配资源. 2.可运行状态: 执行线程的start()方法将为线程分配必须的系统资源,安排其运行,并调用线程体——run()方法,这样就使得该线程处于可运行状态(Runnable). 这一

Java 并发 线程的生命周期

Java 并发 线程的生命周期 @author ixenos 线程的生命周期 线程状态: a)     New 新建 b)     Runnable 可运行 c)     Running 运行 (调用getState()时显示为Runnable) d)     Blocked 阻塞 i.          I/O阻塞 (不释放锁) I/O操作完成解除阻塞,进入Runnable状态 ii.          同步阻塞(不释放锁) 运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会