java线程(1)--概念基础

参考:http://lavasoft.blog.51cto.com/62575/99150

http://blog.csdn.net/baby_newstar/article/details/6783752

http://www.runoob.com/java/java-multithreading.html

1.操作系统中的进程和线程

进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程中可以启动多个线程。比如在Windows系统中,一个运行的exe就是一个进程。 线程是指进程中的一个执行流程,一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程,进程中的多个线程共享进程的内存。

2.java中的线程

一个Java应用总是从main()方法开始运行,mian()方法运行在一个线程内,它被称为主线程。 其他线程通过使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

线程又分用户线程和守护线程。只有通过设置setDaemon(true)的线程才是守护线程。用户线程的生命周期由该线程自定义,比如while(true)一直执行。守护线程的生命周期是由创造它的线程决定的,父线程死掉了,它也就立即死亡而不管是否有任务还没有执行。抽象的理解就是:守护线程是工蜂,蜂后死掉后也会跟着死掉。

3.线程的生命周期

  • 新建状态:使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
  • 就绪状态:当线程对象调用了start()方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要等待JVM里线程调度器的调度。
  • 运行状态:如果就绪状态的线程获取 CPU 资源,就可以执行 run(),此时线程便处于运行状态。处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。
  • 阻塞状态:如果一个线程执行了sleep(睡眠)、suspend(挂起)等方法,失去所占用资源之后,该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。
  • 死亡状态:一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态。
  • 如图:

4.创建一个线程

Java提供了两种创建线程方法:

  • 通过实现Runable接口;
  • 通过继承Thread类本身。

1、如果是扩展java.lang.Thread类的线程,则直接new即可。

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

Thread(Runnable target)  Thread(Runnable target, String name)  Thread(ThreadGroup group, Runnable target)  Thread(ThreadGroup group, Runnable target, String name)  Thread(ThreadGroup group, Runnable target, String name, long stackSize)

4.1实现Runnable接口

package com.test.java.thread;

/**
 * 学习线程
 * Created by mrf on 2016/2/25.
 */
public class NewThread  implements Runnable{
    Thread thread;
    NewThread(){
        //创建第二个新线程
        thread = new Thread(this,"Demo Thread");
        System.out.println("我是实现Runnable接口的类,我被创建了。而且我开始创建另一个线程(name,priority,groupname):"+thread);
        thread.start();
    }

//第二个线程入口
    @Override
    public void run() {
        System.out.println("------------------我是实现Runnable接口的运行入口,我要开始运行了。-----------------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child Thread:"+i);
                //暂停线程
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("Child interrupted");
            e.printStackTrace();
        }
        System.out.println("---------------我这个线程就要运行结束了.------------------------");

    }
}

class ThreadDemo{
    public static void main(String[] args) {
        System.out.println("===========main线程开始运行。==============");
        System.out.println("当前运行的是main线程:"+Thread.currentThread());
        new NewThread();//创建一个新线程
        try {
            for (int i =0; i<5; i++){
                System.out.println("main thread:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main thread interruped.");
            e.printStackTrace();
        }
        System.out.println("==============main线程运行结束.================");
    }
}

运行结果:

===========main线程开始运行。==============
当前运行的是main线程:Thread[main,5,main]
我是实现Runnable接口的类,我被创建了。而且我开始创建另一个线程(name,priority,groupname):Thread[Demo Thread,5,main]
main thread:0
------------------我是实现Runnable接口的运行入口,我要开始运行了。-----------------------
Child Thread:0
Child Thread:1
Child Thread:2
main thread:1
Child Thread:3
Child Thread:4
main thread:2
---------------我这个线程就要运行结束了.------------------------
main thread:3
main thread:4
Disconnected from the target VM, address: '127.0.0.1:4625', transport: 'socket'
==============main线程运行结束.================

分析:

  java程序从main线程开始,这是主线程。然后new NewThread(),创建了这个叫做NewThread的类,这个类的构造方法里面又调用了另一个线程,即从这里开始调用新线程了。main线程和新线程的优先级都为5,因此轮换使用cpu,所以才会出现交替打印的现象。

问题:上面的结果显示自线程运行结束后main线程才结束,那么子线程的生命周期和main有关吗?

答案是否定的,下面我将子线程的运行时间加长就会看到结果。

package com.test.java.thread;

/**
 * 学习线程
 * Created by mrf on 2016/2/25.
 */
public class NewThread  implements Runnable{
    Thread thread;
    NewThread(){
        //创建第二个新线程
        thread = new Thread(this,"Demo Thread");
        System.out.println("我是实现Runnable接口的类,我被创建了。而且我开始创建另一个线程(name,priority,groupname):"+thread);
        thread.start();
    }

//第二个线程入口
    @Override
    public void run() {
        System.out.println("------------------我是实现Runnable接口的运行入口,我要开始运行了。-----------------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child Thread:"+i);
                //暂停线程
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            System.out.println("Child interrupted");
            e.printStackTrace();
        }
        System.out.println("---------------我这个线程就要运行结束了.------------------------");

    }
}

class ThreadDemo{
    public static void main(String[] args) {
        System.out.println("===========main线程开始运行。==============");
        System.out.println("当前运行的是main线程:"+Thread.currentThread());
        new NewThread();//创建一个新线程
        try {
            for (int i =0; i<5; i++){
                System.out.println("main thread:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main thread interruped.");
            e.printStackTrace();
        }
        System.out.println("==============main线程运行结束.================");
    }
}

结果:

===========main线程开始运行。==============
当前运行的是main线程:Thread[main,5,main]
我是实现Runnable接口的类,我被创建了。而且我开始创建另一个线程(name,priority,groupname):Thread[Demo Thread,5,main]
main thread:0
------------------我是实现Runnable接口的运行入口,我要开始运行了。-----------------------
Child Thread:0
main thread:1
main thread:2
main thread:3
main thread:4
==============main线程运行结束.================
Child Thread:1
Child Thread:2
Child Thread:3
Child Thread:4
---------------我这个线程就要运行结束了.------------------------

注意我将子线程的睡眠时间改成了500.这样,main线程执行完毕后子线程仍然继续执行。这个有点可以使我们在做业务代码时将不要紧的代码多线程异步执行,优化运行体验和效率。

4.2守护线程演示

还是上面的代码,我将子线程设置为守护线程,并且设置子线程运行时间>main线程,看是否main线程运行结束后守护线程直接死掉。这里注意,setDaemon一定要放在start前,因为会判断isAlive,如果活着就不能设置为守护线程了,因为已经在运行了。

package com.test.java.thread;

/**
 * 学习线程
 * Created by mrf on 2016/2/25.
 */
public class NewThread  implements Runnable{
    Thread thread;
    NewThread(){
        //创建第二个新线程
        thread = new Thread(this,"Demo Thread");
        System.out.println("我是实现Runnable接口的类,我被创建了。而且我开始创建另一个线程(name,priority,groupname):"+thread);
        thread.setDaemon(true);
        thread.start();
    }

//第二个线程入口
    @Override
    public void run() {
        System.out.println("------------------我是实现Runnable接口的运行入口,我要开始运行了。-----------------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("Child Thread:"+i);
                //暂停线程
                Thread.sleep(500);
            }
        } catch (InterruptedException e) {
            System.out.println("Child interrupted");
            e.printStackTrace();
        }
        System.out.println("---------------我这个线程就要运行结束了.------------------------");

    }
}

class ThreadDemo{
    public static void main(String[] args) {
        System.out.println("===========main线程开始运行。==============");
        System.out.println("当前运行的是main线程:"+Thread.currentThread());
        new NewThread();//创建一个新线程
        try {
            for (int i =0; i<5; i++){
                System.out.println("main thread:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main thread interruped.");
            e.printStackTrace();
        }
        System.out.println("==============main线程运行结束.================");
    }
}

运行结果:

===========main线程开始运行。==============
当前运行的是main线程:Thread[main,5,main]
我是实现Runnable接口的类,我被创建了。而且我开始创建另一个线程(name,priority,groupname):Thread[Demo Thread,5,main]
main thread:0
------------------我是实现Runnable接口的运行入口,我要开始运行了。-----------------------
Child Thread:0
main thread:1
main thread:2
main thread:3
main thread:4
Child Thread:1
Disconnected from the target VM, address: '127.0.0.1:6928', transport: 'socket'
==============main线程运行结束.================

和上一个测试对比相当明显,child thread仅仅打印了一次就结束了,说明它死掉了,说明创建他的main线程死掉后,她跟着死掉。

 4.3继承Thread

通过继承Thread,重写run方法来实现多线程。下面是实例,另外上面的代码写的不太清楚,start方法应该放外面来调用比较好。

package com.test.java.thread;

/**
 * 多线程学习---继承Thread
 * Created by mrf on 2016/2/25.
 */
public class NewThreadExtend  extends Thread{
    NewThreadExtend(){
        //创建第二个线程
        super("Demo Thread.");
        System.out.println("子线程:"+this);
    }

    //通过重写run方法来实现线程业务逻辑
    public void run(){
        System.out.println("-------我是子线程,我开始运行----------------");
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("子线程:"+i);
                Thread.sleep(50);
            }
        } catch (InterruptedException e) {
            System.out.println("子线程interrupted");
            e.printStackTrace();
        }
        System.out.println("-------我是子线程,我结束运行----------------");
    }

}

class ExtendThread{
    public static void main(String[] args) {
        System.out.println("========我是main线程,我开始运行:"+Thread.currentThread());
        NewThreadExtend newThreadExtend = new NewThreadExtend();
        newThreadExtend.start();
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("main线程:"+i);
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            System.out.println("main线程interrupted.");
            e.printStackTrace();
        }
        System.out.println("========main线程运行结束=====================");
    }
}

运行结果:

========我是main线程,我开始运行:Thread[main,5,main]
子线程:Thread[Demo Thread.,5,main]
main线程:0
-------我是子线程,我开始运行----------------
子线程:0
子线程:1
main线程:1
子线程:2
子线程:3
子线程:4
main线程:2
-------我是子线程,我结束运行----------------
main线程:3
main线程:4
Disconnected from the target VM, address: '127.0.0.1:11051', transport: 'socket'
========main线程运行结束=====================

5.Thread的方法

 方法就不在这里赘述了,普通方法必须由thread对象来调用,比如start,静态方法可以由Thread来调用。这里再说下start,start执行的是run方法,初学的时候会很纳闷,因为没有深入源码。好吧,我也没深入,但大概看到start是加入group,然后调用start0,start0是个native method。啥是native method?看到介绍说是调用其他语言实现的代码,到这里就是jvm干的事情了,我们不知道做了什么。不过可以猜测是和操作系统交互,获取进程资源之类的吧,然后应该回调run方法。总之,要理解start就是在执行run方法,不过start看起来像是代理而已。

public void start() 使该线程开始执行;Java 虚拟机调用该线程的 run 方法。

 6.线程的几个概念

在多线程编程时,你需要了解以下几个概念:

  • 线程同步
  • 线程间通信
  • 线程死锁
  • 线程控制:挂起、停止和恢复

 7.线程同步和锁下次学习

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏余林丰

12.ThreadPoolExecutor线程池原理及其execute方法

jdk1.7.0_79   对于线程池大部分人可能会用,也知道为什么用。无非就是任务需要异步执行,再者就是线程需要统一管理起来。对于从线程池中获取线程,大部分...

1857
来自专栏闻道于事

Java之线程,常用方法,线程同步,死锁

1, 线程的概念 进程与线程 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。(进程是资源分配的最...

2999
来自专栏Janti

由浅入深理解Java线程池及线程池的如何使用

前言 多线程的异步执行方式,虽然能够最大限度发挥多核计算机的计算能力,但是如果不加控制,反而会对系统造成负担。线程本身也要占用内存空间,大量的线程会占用内存资源...

7069
来自专栏向治洪

java线程池

一简介 线程的使用在java中占有极其重要的地位,在jdk1.4极其之前的jdk版本中,关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。...

1856
来自专栏一名合格java开发的自我修养

java并发线程池---了解ThreadPoolExecutor就够了

总结:线程池的特点是,在线程的数量=corePoolSize后,仅任务队列满了之后,才会从任务队列中取出一个任务,然后构造一个新的线程,循环往复直到线程数量达到...

761
来自专栏老马说编程

(78) 线程池 / 计算机程序的思维逻辑

上节,我们初步探讨了Java并发包中的任务执行服务,实际中,任务执行服务的主要实现机制是线程池,本节,我们就来探讨线程池。 基本概念 线程池,顾名思义,就是一...

1767
来自专栏cmazxiaoma的架构师之路

关于Java多线程的一些常考知识点

1373
来自专栏项勇

笔记 34 | java线程之Thread线程优先

1545
来自专栏杂烩

Java-ThreadPoolExecutor类

        handler:提交线程数量大于maximumPoolSize时的处理器

622
来自专栏云霄雨霁

Java--五态模型&控制线程

1415

扫描关注云+社区