Java并发编程-多线程基础

程序员文章站 2022-04-07 17:57:26

1.多线程概述1、什么是进程？什么是线程？进程是一个应用程序（1个进程是一个软件）。线程是一个进程中的执行场景/执行单元。一个进程可以启动多个线程。2、对于java程序来说，当在DOS命令窗口中输入：java HelloWorld 回车之后。会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。同时再启动一个垃圾回收线程负责看护，回收垃圾。最起码，现在的java程序中至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主...

Java多线程基础

1.多线程概述
实现线程的两种方式
- 继承Thread类
- 实现Runnable接口
2.线程生命周期
获取线程的名字和线程对象
3.线程的休眠
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方法结束只是主线程结束了，主栈空了，其它的栈(线程)可能还在压栈弹栈。
Java并发编程-多线程基础
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{
	@Override
	public void run() {
		//编写程序，这段程序运行在分支线程中（分支栈）
		for(int i=0;i<1000;i++){
			System.out.println("分支线程---->"+i);
		}
	}
}

以下程序的输出结果有这样的特点:
有先有后，有多有少。
Java并发编程-多线程基础

Java并发编程-多线程基础
总结：
第一种方式：编写一个类，直接继承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{

	@Override
	public 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(){
			@Override
			public 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-0
		MyThread2 t2=new MyThread2();
		System.out.println(t2.getName());	//默认名为Thread-1
		//启动线程
		t.start();
	
	}
}
class MyThread2 extends Thread{
	@Override
	public void run() {
		//current就是当前线程对象，当前线程是谁呢
		//当t1线程执行run方法，当前线程就是t1
		//当t2线程执行run方法，当前线程就是t2
		Thread 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 block
				e.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 block
			e.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");
	}
	
}

Java并发编程-多线程基础
中间间隔很短的时间

强行终止一个线程，

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 block
			e.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 block
				e.printStackTrace();
			}
		}
	}
	
}

Java并发编程-多线程基础

合理的终止一个线程的执行

怎么合理的终止一个线程的执行，这种方式是很常用的

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 block
			e.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 block
					e.printStackTrace();
				}
			}else{
				//return就结束了，你在结束之前还有什么没保存的，在这里保存就行了。
				//终止当前线程的执行
				return ;
			}
			
		}
	}
}

Java并发编程-多线程基础

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 stub
		System.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);
		}
		
	}
}

处于运行状态的时间多一些
Java并发编程-多线程基础

线程让位

让位：当前运行的线程暂停，会到就绪状态，让给其他线程
静态方法：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);
		}	
	}
}

Java并发编程-多线程基础

线程合并

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 block
			e.printStackTrace();
		}		//t合并到当前线程中，当前线程受阻塞。t线程执行直到结束。
		System.out.println("main over");
	}
}
class MyRunnable7 implements Runnable{
	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			System.out.println(Thread.currentThread().getName()+"---->"+i);
		}
	}
}

Java并发编程-多线程基础

本文地址：https://blog.csdn.net/qq_39736597/article/details/111823708

相关标签： Java 多线程并发编程

上一篇：《java编程思想》学习笔记，学习中。。。

下一篇：《JAVA300集》IO流_处理流-day17

Java并发编程-多线程基础

Java多线程基础

1.多线程概述

实现线程的两种方式

继承Thread类

实现Runnable接口

2.线程生命周期

获取线程的名字和线程对象

3.线程的休眠

sleep方法

终止线程的休眠

强行终止一个线程，

合理的终止一个线程的执行

4.线程调度

线程调度概述

线程优先级

线程让位

线程合并

Java并发 CompletableFuture异步编程的实现

【Java并发】基础

Java日期时间API系列5-----Jdk7及以前的日期时间类TimeUnit在并发编程中的应用

并发编程之Java锁

Java并发编程：Callable、Future和FutureTask---转载测试

零基础学员学习Java时，如何打好基础并形成编程思维？

举例说明Java多线程编程中读写锁的使用

java并发编程-12个原子类

python基础-并发编程part01

1.java小作业-计算1到100的整合-指定输入多少行输出就打印多少行-打印24小时60分钟每一分钟-重载基础练习-面向java编程初学者