目录
一:认识线程:
二、线程的优点:
三、进程和线程的区别(面试题):
四、第一个多线程程序:
五、创建线程的方式:
六、Thread类及常用方法
Thread类常见构造方法:
Thread(String name)
Thread(Runnable target,String name)
Thread常见属性:
ID&名称:
状态:
优先级
后台线程
存活
中断
一:认识线程:
每一个线程就是一个“执行流”。每个线程之间都可以按照顺序执行自己的代码,多个线程之间可以同时执行自己的代码。比如我们之前一直写的程序都只是在main线程中写的代码,以前写的代码都是单个线程的。
那么为什么会出现线程?主要有2个原因:
1)并发编程的需要
单核CPU的发展已经到了瓶颈,现在已经到了多核CPU的时代,而并发编程可以让CPU的资源得到充分的利用。
2)进程太“重”了。
虽然进程也可以实现并发编程,但是进程还是太“重”了。
进程在创建时开销非常大
进程在销毁是开销非常大
进程在调度的时候也开销非常大!
我们这里所说的“重”指的是“资源分配/回收”。
二、线程的优点:
所以我们的线程就应运而生。相对于进程而言。线程就更加的“轻量化”了,所以线程也被称为“轻量化进程”。这里说的轻量是因为线程在创建、销毁和调度的时候的开销都要比进程低。而线程之所以开销低的原因又在于线程省去了一些“申请资源和释放资源的步骤”。
比如这样的一个例子:
小明家开了一个工厂来生产冰箱,经过了一段时间的经营,发现生产的冰箱非常的受欢迎,销量很高,于是小明想到了两种方案来提高生产力:
方案一(多进程方案):再寻找一个工业场地,购进一批同样的机器来进行生产。
方案二(多线程方案):把原工厂的地方拾掇拾掇,腾出一块地方,购进一批新的机器放机器进行生产
显然我们可以看出,第二种方案(多线程)的开销要明显低于第一种方案(多进程)。因为第二种方案没有进行更大的资源开销,而是在原工厂的基础上进行了复用,也就是还是利用了原场地。这样下来的开销就大大减少了。
三、进程和线程的区别(面试题):
1.、进程包含线程。一个进程中可以有一个线程,也可以有多个线程。
2、进程和线程都可以解决并发编程问题,但是进程在频繁的创建和销毁的时候开销更大,线程更小。(线程比进程更加的轻量)
3、进程是操作系统资源分配的基本单位,线程是操作系统进行调度的基本单位。
4、进程与进程之间不共享内存空间,同一个进程中的线程共享内存空间。(这就可能会出现一个线程崩了,别的也会收到影响,而进程之间不会影响。也就是说进程比线程更安全)
四、第一个多线程程序:
线程是操作系统里面的概念,Java标准库中的Thread类可以视为是对操作系统提供的API进行了抽象和封装。
通过第一个多线程的程序感受一下多线程和单一线程的区别。
package Thread;
class myThread extends Thread{
//使用一个boolean类型进行判断,让该线程只打印100次
private boolean flag=true;
private int count=1;
@Override
public void run() {
while(flag){
if(count==100){
flag=false;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("hello Thread");
count++;
}
}
}
public class ThreadDemo2 {
public static void main(String[] args) throws InterruptedException {
Thread t=new myThread();
t.start();
//主线程打印50次
for (int i = 0; i <50 ; i++) {
Thread.sleep(500);
System.out.println("hello main");
}
}
}
该程序并没有先执行其中一个线程,在执行另一个的线程,这就是多线程的魅力所在。
我们从上述结果中也可以看到一个现象就是main线程和t线程谁先执行是不确定的,是完全由我们的系统自己决定的。所以线程的调度是“抢占式执行,随机调度”。
五、创建线程的方式:
我们创建线程可以有五种方式:
1、创建子类继承Thread类,重写run方法。
package Thread;
class myThread1 extends Thread{
@Override
public void run() {
System.out.println("hello Thread");
}
}
public class ThreadDemo3 {
public static void main(String[] args) {
Thread t1=new myThread1();
t1.start();
}
}
run方法描述了该线程要执行的任务内容,即要执行的代码,而调用start方法才是真正创建了线程,才会执行任务。
2、实现Runnable接口,重写run方法。
package Thread;
class myRunnable implements Runnable{
@Override
public void run() {
System.out.println("hello Thread");
}
}
public class ThreadDemo4 {
public static void main(String[] args) {
myRunnable runnable=new myRunnable();
Thread t=new Thread(runnable);
t.start();
}
}
这个方法是通过实现Runnable接口,创建出一个Runnable的实例,把这个实例传给Thread对象,通过这个实例来描述要执行的任务。
3、匿名内部类创建Thread子类对象。
package Thread;
public class ThreadDemo5 {
public static void main(String[] args) {
Thread t=new Thread(){
@Override
public void run() {
System.out.println("hello Thread");
}
};
t.start();
}
}
4、匿名内部类创建Runnable子类对象
package Thread;
public class ThreadDemo6 {
public static void main(String[] args) {
Thread t = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello Thread");
}
});
t.start();
}
}
5、使用lambda表达式(最推荐写法)
package Thread;
public class ThreadDemo7 {
public static void main(String[] args) {
Thread t=new Thread(()->{
System.out.println("hello Thread");
});
t.start();
}
}
六、Thread类及常用方法
Thread类常见构造方法:
Thread(String name)
这个方法就是在我们创建线程的时候,对线程进行命名。我们上面的t线程这样的说法注意这里的t是指Thread对象,不是我们线程的名字。所以我们可以通过这个方法对线程进行命名,避免线程混乱的情况。
package Thread;
public class ThreadDemo8 {
public static void main(String[] args) {
Thread t=new Thread(()->{
while (true) {
System.out.println("hello Thread10086");
}
},"Thread10086");
t.start();
}
}
然后我们运行后可以通过java的jdk自带的工具程序来进行线程的管理和监视。这就用到了我们的jconsole工具。
然后就是介绍一下Thread(Runnable target,String name)
Thread(Runnable target,String name)
这个就是上述的使用Runnable对象来创建线程的方法了。
package Thread;
public class ThreadDemo9 {
public static void main(String[] args) {
Thread t=new Thread(new Runnable() {
@Override
public void run() {
while (true){
System.out.println("hello Thread10010");
}
}
},"Thread10010");
t.start();
}
}
然后我们通过jconsole观察一下:
然后下面是Thread的几个常用的属性。
Thread常见属性:
属性 | 获取方法 |
ID | getId() |
名称 | getName() |
状态 | getState() |
优先级 | getPriority() |
是否后台线程 | isDaemon() |
是否存活 | isAlive() |
是否被中断 | isInterrupted() |
ID&名称:
id是每个线程独一无二的身份标识。
名称是每个线程的名字。
package Thread;
public class ThreadDemo10 {
public static void main(String[] args) {
Thread t1=new Thread(()->{
},"T1");
Thread t2=new Thread(()->{
},"T2");
t1.start();
t2.start();
System.out.println(t1.getId());
System.out.println(t2.getId());
System.out.println(t1.getName());
System.out.println(t2.getName());
}
}
状态:
状态是当前线程所处的状态。
线程的状态有以下几种:
1、NEW 安排了工作,还没有开始行动
2、RUNNABLE 可工作的(包括正在工作和即将开始工作)
3 、TERMINATED 工作完成了
4、BLOCKED 排队等待其他事情
5、WAITING 排队等待其他事情
6、TIMED_WAITING 排队等待其他事情
NEW
首先说一下NEW,这个就是在我们的run方法中没有进行任务的执行。
package Thread;
public class ThreadDemo11 {
public static void main(String[] args) {
Thread t=new Thread(()->{
System.out.println("hello");
});
// t.start();
System.out.println(t.getState());
}
}
我们没有进行线程的启动,就说明了我们只是描述了任务是什么(打印hello),但是没有去执行这个任务,所以状态就是NEW
RUNNABLE
那么我们如果的任务没有进行描述,但是我们启动了线程,就相当于老板没有给员工下达任务,员工此时就是可以执行任务的状态RUNNABLE(就是闲着)。
package Thread;
public class ThreadDemo12 {
public static void main(String[] args) {
Thread t=new Thread(()->{
});
t.start();
System.out.println(t.getState());
}
}
TERMINATED
这个就是表示线程执行完毕了。我们可以用以下代码做理解。
package Thread;
public class ThreadDemo12 {
public static void main(String[] args) {
Thread t=new Thread(()->{
});
t.start();
//使用一个sleep使得t线程先执行完毕
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(t.getState());
}
}
BLOCKED
BLOCKED这个状态常见于加锁状态,当我们对其进行加锁(synchronized)之后 ,别的对象来获取锁的时候就需要阻塞等待,直到加锁的对象释放锁之后,才有机会获取到锁。
目前先知道对一个代码块加锁后就会出现所谓的加锁状态即可,后面会告诉大家为什么我们要进行加锁操作。
WAITING
WAITING表示排队等待其他事情。(这里先不展开,后面会介绍)
TIMED_WAITING
TIMED_WAITING也表示排队等待其他事情,但是这里的排队是由于系统调用了sleep方法而进入的状态。表示了当前线程需要阻塞等待一定的时间。
package Thread;
public class ThreadDemo14 {
public static void main(String[] args) {
Thread t=new Thread(()->{
while (true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
t.start();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(t.getState());
}
}
附赠状态一览表(简略示意):
优先级
优先级高的线程理论上来说更容易被调度到
后台线程
关于后台线程,需要记住一点:JVM会在一个进程的所有非后台线程结束后,才会结束运行
存活
是否存活,即简单的理解,为 run 方法是否运行结束了
中断
有关线程中断的问题我们后面再总结,这点的篇幅可能会有点长,不便于总结在此处。
好了,今天的认识线程&Thread类及常用方法&线程状态就大概总结到这里了,下一篇准备总结一下有关线程安全的那些事。