Java多线程基础
1.多线程概述实现线程的两种方式继承Thread类实现Runnable接口2.线程生命周期获取线程的名字和线程对象3.线程的休眠sleep方法终止线程的休眠强行终止一个线程,合理的终止一个线程的执行4.线程调度线程调度概述线程优先级线程让位线程合并1.多线程概述
1、什么是进程?什么是线程?
进程是一个应用程序(1个进程是一个软件)。 线程是一个进程中的执行场景/执行单元。 一个进程可以启动多个线程。
2、对于java程序来说,当在DOS命令窗口中输入:java HelloWorld 回车之后。
会先启动JVM,而JVM就是一个进程。
JVM再启动一个主线程调用main方法。
同时再启动一个垃圾回收线程负责看护,回收垃圾。
最起码,现在的java程序中至少有两个线程并发,
一个是垃圾回收线程,一个是执行main方法的主线程。
3、进程和线程是什么关系?举个例子
阿里巴巴:进程
马云:阿里巴巴的一个线程
童文红:阿里巴巴的一个线程
京东:进程
强东:京东的一个线程
妹妹:京东的一个线程
进程可以看做是现实生活当中的公司。
线程可以看做是公司当中的某个员工。
注意:
进程A和进程B的内存独立不共享。(阿里巴巴和京东资源不会共享的!)
魔兽游戏是一个进程
酷狗音乐是一个进程
这两个进程是独立的,不共享资源。
线程A和线程B呢?
在java语言中:
线程A和线程B,堆内存和方法区内存共享。
但是栈内存独立,一个线程一个栈。
假设启动10个线程,会有10个栈空间,每个栈和每个栈之间, 互不干扰,各自执行各自的,这就是多线程并发。
火车站,可以看做是一个进程。
火车站中的每一个售票窗口可以看做是一个线程。
我在窗口1购票,你可以在窗口2购票,你不需要等我,我也不需要等你。
所以多线程并发可以提高效率。
java中之所以有多线程机制,目的就是为了提高程序的处理效率。
4、思考一个问题:
使用了多线程机制之后,main方法结束,是不是有可能程序也不会结束。 main方法结束只是主线程结束了,主栈空了,其它的栈(线程)可能还在压栈弹栈。
5、分析一个问题:对于单核的CPU来说,真的可以做到真正的多线程并发吗?
对于多核的CPU电脑来说,真正的多线程并发是没问题的。
4核CPU表示同一个时间点上,可以真正的有4个进程并发执行。
什么是真正的多线程并发?
t1线程执行t1的。
2线程执行t2的。
t1不会影响t2,t2也不会影响t1。这叫做真正的多线程并发。
单核的CPU表示只有一个大脑:
不能够做到真正的多线程并发,但是可以做到给人一种“多线程并发”的感觉。
对于单核的CPU来说,在某一个时间点上实际上只能处理一件事情,但是由于
CPU的处理速度极快,多个线程之间频繁切换执行,跟人来的感觉是:多个事情同时在做!!!!!
线程A:播放音乐
线程B:运行魔兽游戏
线程A和线程B频繁切换执行,人类会感觉音乐一直在播放,游戏一直在运行,
给我们的感觉是同时并发的。
电影院采用胶卷播放电影,一个胶卷一个胶卷播放速度达到一定程度之后,人类的眼睛产生了错觉,感觉是动画的。这说明人类的反应速度很慢,就像一根钢针扎到手上,到最终感觉到疼,这个过程是需要“很长的”时间的,在这个期间计算机可以进行亿万次的循环。所以计算机的执行速度很快。
实现线程的两种方式
继承Thread类
java语言中,实现线程有两种方式,那两种方式呢?
java支持多线程机制。并且java已经将多线程实现了,我们只需要继承就行了。
第一种方式:编写一个类,直接继承java.lang.Thread,重写run方法。
怎么创建线程对象?new就行了 怎么启动线程?调用线程对象的start方法
注意:方法体当中的代码永远都是自上而下的顺序依次逐行执行。
public class ThreadTest01 {public static void main(String[] args) {//这里是main方法,这里的代码属于主线程,在主栈中运行//新建一个分支线程对象MyThread myThread =new MyThread();//启动线程。//start()方法作用是:启动一个分支线程,//在jvm中开辟一个新的栈空间,这段代码任务完成后,瞬间就结束了。//这段代码的任务只是为了开启一个新的栈空间,//只要新的栈空间开出来,start()方法就结束了,线程就启动成功了。//启动成功的线程会自动调用run方法,并且run方法在分支栈的栈底部(压栈)//run方法在分支栈的栈底部,main方法在主栈的栈底部。run和main是平级的//myThread.run();//不会启动线程,不会分配新的分支栈myThread.start();//这里的代码还是运行在主线程中for(int i=0;i<1000;i++){System.out.println("主线程---->"+i);}}}class MyThread extends Thread{@Overridepublic void run() {//编写程序,这段程序运行在分支线程中(分支栈)for(int i=0;i<1000;i++){System.out.println("分支线程---->"+i);}}}
以下程序的输出结果有这样的特点:
有先有后,有多有少。
总结: 第一种方式:编写一个类,直接继承java.lang.Thread,重写run方法。
// 定义线程类public class MyThread extends Thread{public void run(){}}// 创建线程对象MyThread t = new MyThread();// 启动线程。t.start();
实现Runnable接口
编写一个类,实现java.lang.Runnable接口,实现run方法。
public class ThreadTest02 {public static void main(String[] args) {//创建一个可运行的对象,将可运行的对象封装成一个线程对象Thread t=new Thread(new MyRunnable());//启动线程t.start();for(int i=0;i<100;i++){System.out.println("主线程---->"+i);}}}//这并不是一个线程类,是一个可运行的类,它还不是一个线程。class MyRunnable implements Runnable{@Overridepublic void run() {for(int i=0;i<100;i++){System.out.println("分支线程---->"+i);}}}
总结:
// 定义一个可运行的类public class MyRunnable implements Runnable {public void run(){}}// 创建线程对象Thread t = new Thread(new MyRunnable());// 启动线程t.start();
注意:第二种方式实现接口比较常用,因为一个类实现了接口,它还可以去继承其它的类,更灵活。 采用匿名内部类的方式
public class ThreadTest03 {public static void main(String[] args) {//创建线程对象,采用匿名内部类方式//这是通过一个没有名字的类,new出来的对象。接口是没有办法new对象的Thread t=new Thread(new Runnable(){@Overridepublic void run() {for(int i=0;i<100;i++){System.out.println("分支线程---->"+i);}}});t.start();for(int i=0;i<100;i++){System.out.println("主线程---->"+i);}}}
2.线程生命周期
关于线程对象的生命周期?
新建状态
就绪状态
运行状态
阻塞状态
死亡状态
获取线程的名字和线程对象
1.怎么获取当前线程对象
static Thread currentThread() Thread t=Thread.currentThread() t代表当前线程对象
2.获取线程对象的名字
线程对象.getName()
3.修改线程对象的名字
线程对象.setName(“线程的名字”);
4.当线程没有设置名字的时候,默认的名字有什么规律
Thread-0
Thread-1
public class ThreadTest04 {public static void main(String[] args) {//currentThread就是当前线程对象//这个代码出现在main方法中,所以当前线程就是主线程Thread currentThread=Thread.currentThread();System.out.println(currentThread.getName());//创建线程对象MyThread2 t=new MyThread2();//设置线程对象的名字t.setName("tttt");//获取线程的名字String tName=t.getName();System.out.println(tName);//默认名为Thread-0MyThread2 t2=new MyThread2();System.out.println(t2.getName());//默认名为Thread-1//启动线程t.start();}}class MyThread2 extends Thread{@Overridepublic void run() {//current就是当前线程对象,当前线程是谁呢//当t1线程执行run方法,当前线程就是t1//当t2线程执行run方法,当前线程就是t2Thread currentThread=Thread.currentThread();System.out.println("分支线程"+currentThread.getName());for(int i=0;i<100;i++){System.out.println("分支线程"+i);}}}
3.线程的休眠
sleep方法
static void sleep(long mills)
1.静态方法 Thread.sleep(1000) 2.参数是毫秒 3.作用:让当前线程进入休眠,进入”阻塞状态“,放弃占用的CPU时间片,让给其他线程使用
这行代码出现在A线程中,A线程就会进入休眠。
这行代码出现在B线程中,B线程就会进入休眠。
4.Thread.sleep()方法,可以做到这种效果
间隔特定的时间,去执行一段特定的代码,每隔多久执行一次。
public class ThreadTest05 {public static void main(String[] args) {////让当前线程进入休眠,睡眠5秒////当前线程是主线程//try {//Thread.sleep(1000*5);//} catch (InterruptedException e) {//// TODO Auto-generated catch block//e.printStackTrace();//}////5秒之后执行这里的代码//System.out.println("hello,world");for(int i=0;i<10;i++){System.out.println(Thread.currentThread().getName()+" "+i);//睡眠1秒try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}
sleep方法是静态方法,它是让当前线程进入休眠。这行代码出现在哪个线程中,哪个线程就会睡眠。
sleep睡眠太久了,如果希望半道上醒来,你应该怎么办?也就说怎么叫醒一个正在睡眠的线程
注意:这个不是中断线程的执行,是终止线程的睡眠
用interrupt()方法终止t线程的睡眠(这种中断睡眠的方式依靠了java的异常机制)
终止线程的休眠
public class ThreadTest07 {public static void main(String[] args) {Thread t=new Thread(new MyRunnable2());t.setName("t");t.start();//希望5秒后,t线程醒来(5秒之后主线程手里的活儿干完了)try {Thread.sleep(1000*5);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//终止t线程的睡眠(这种中断睡眠的方式依靠了java的异常机制)t.interrupt();//干扰,一盆冷水过去!}}class MyRunnable2 implements Runnable{//重点:run()当中的异常不能throw,只能trycatch//因为run()方法在父类中没有抛出任何异常,子类不能比父类抛出更多的异常public void run() {System.out.println(Thread.currentThread().getName()+"---->begin");try {//睡眠1小时Thread.sleep(1000*60*60);} catch (InterruptedException e) {// TODO Auto-generated catch block//e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"---->end");}}
中间间隔很短的时间
强行终止一个线程,
stop()方法这种方式存在很大的缺点:容易丢失数据,因为这种方式是直接将线程杀死了,
线程原有保存的数据会丢失,不建议使用 终止线程的执行
public class ThreadTest08 {public static void main(String[] args) {Thread t=new Thread(new MyRunnable3());t.setName("t");t.start();//模拟5秒try {Thread.sleep(1000*5);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//5秒之后强行终止t线程t.stop();//已过时,不建议使用。}}class MyRunnable3 implements Runnable{public void run() {for(int i=0;i<10;i++){System.out.println(Thread.currentThread().getName());try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}
合理的终止一个线程的执行
怎么合理的终止一个线程的执行,这种方式是很常用的
public class ThreadTest09 {public static void main(String[] args) {MyRunnable4 r=new MyRunnable4();Thread t=new Thread(r);t.setName("t");t.start();//模拟5秒try {Thread.sleep(5000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//5秒之后强行终止t线程r.run=false;}}class MyRunnable4 implements Runnable{public boolean run=true;public void run() {//打一个bool标记for(int i=0;i<10;i++){if(run){System.out.println(Thread.currentThread().getName()+"---->"+i);try {Thread.sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}else{//return就结束了,你在结束之前还有什么没保存的,在这里保存就行了。//终止当前线程的执行return ;}}}}
4.线程调度
线程调度概述
关于线程的调度
1.1、常见的线程调度模型有哪些?
抢占式调度模型:
那个线程的优先级比较高,抢到的CPU时间片的概率就高一些/多一些。
java采用的就是抢占式调度模型。
均分式调度模型:
平均分配CPU时间片。每个线程占有的CPU时间片时间长度一样。
平均分配,一切平等。
有一些编程语言,线程调度模型采用的是这种方式。
1.2、java中提供了哪些方法是和线程调度有关系的呢?
实例方法:
void setPriority(int newPriority) 设置线程的优先级
int getPriority() 获取线程优先级
最低优先级1 默认优先级是5 最高优先级10
优先级比较高的获取CPU时间片可能会多一些。(但也不完全是,大概率是多的。)
静态方法:
static void yield() 让位方法
暂停当前正在执行的线程对象,并执行其他线程
yield()方法不是阻塞方法。让当前线程让位,让给其它线程使用。
yield()方法的执行会让当前线程从“运行状态”回到“就绪状态”。
注意:在回到就绪之后,有可能还会再次抢到。
void join()合并线程
class MyThread1 extends Thread {public void doSome(){MyThread2 t = new MyThread2();t.join(); // 当前线程进入阻塞,t线程执行,直到t线程结束。当前线程才可以继续。}}class MyThread2 extends Thread{}
线程优先级
public class ThreadTest10 {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("最高优先级"+Thread.MAX_PRIORITY);System.out.println("最低优先级"+Thread.MIN_PRIORITY);System.out.println("默认优先级"+Thread.NORM_PRIORITY);//获取当前线程对象,获取当前线程的优先级Thread currentThread = Thread.currentThread();System.out.println(currentThread.getName()+"线程的默认优先级是:"+currentThread.getPriority());Thread t=new Thread(new MyRunnable5());t.setName("t");t.setPriority(8);t.start();//优先级较高的,只是抢到的CPU时间片相对多一些//大概率方向更偏向于优先级较高的for(int i=0;i<1000;i++){System.out.println(Thread.currentThread().getName()+"---->"+i);}}}class MyRunnable5 implements Runnable{public void run() {System.out.println(Thread.currentThread().getName()+"线程的默认优先级是:"+Thread.currentThread().getPriority());for(int i=0;i<1000;i++){System.out.println(Thread.currentThread().getName()+"---->"+i);}}}
处于运行状态的时间多一些
线程让位
让位:当前运行的线程暂停,会到就绪状态,让给其他线程 静态方法:Thread.yield()
public class ThreadTest11 {public static void main(String[] args) {Thread t=new Thread(new MyRunnable6());t.setName("t");t.start();for(int i=0;i<1000;i++){System.out.println(Thread.currentThread().getName()+"---->"+i);}}}class MyRunnable6 implements Runnable{public void run() {//假设每100个让位一次for(int i=0;i<1000;i++){if(i%100==0){Thread.yield();//当前线程暂停一下,让给主线程}System.out.println(Thread.currentThread().getName()+"---->"+i);}}}
线程合并
public class ThreadTest12 {public static void main(String[] args) {System.out.println("main begin");Thread t=new Thread(new MyRunnable7());t.setName("t");t.start();//合并线程try {t.join();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}//t合并到当前线程中,当前线程受阻塞。t线程执行直到结束。System.out.println("main over");}}class MyRunnable7 implements Runnable{@Overridepublic void run() {for(int i=0;i<1000;i++){System.out.println(Thread.currentThread().getName()+"---->"+i);}}}