Java线程（一）基础知识

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量457 收藏 7
点赞数 3
分类专栏： 线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010184528/article/details/105334069
版权

目录

理解线程的概念

线程的创建方式

Thread

实现Runnable接口

线程的5种状态

（创建、就绪、执行、阻塞、终止）

线程常用方法

线程同步synchronized

理解线程的概念

  1. 一个程序至少有一个进程，一个进程至少有一个线程；
  2. 线程是进程的一个实体，是CPU调度和分派的基本单位；
  3. 一个线程可以创建和撤销另一个线程；
  4. 同一个进程中的多个线程之间可以并发执行
  5. 在Java中，每次程序运行至少启动2个线程：一个是main线程，一个是垃圾收gc集线程。每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启动了一个进程；
  6. 多线程可以等价于多任务，当有多个任务要处理，多个任务一起做所消耗的时间比任务串行起来所消耗的时间短；
  7. 可以通过Thead和Runnable两种方式创建线程；
  8. 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止；
  9. 多个线程同时运行的时候，每段时间片中只执行一个线程;
  10. 线程创建成功启动之后，并不是马上执行，而是等待CPU创建分配时间片之后才会真正执行，多个线程谁先抢到时间片，谁就先执行；
  11. main主线程也许会在自线程之后执行（下面有例子），也就是说线程的执行顺序，默认情况下人为不能改变执行顺序；
  12. 线程的生命周期只有一次；

线程的创建方式

Thread

public class ThreadTest {

	public static void main(String[] args) {
		
		MyThread t1=new MyThread();
		t1.start();
		
		MyThread t2=new MyThread();
		t2.start();
		
		MyThread t3=new MyThread();
		t3.start();
	
		System.out.println("main");
	}
	
	
  static class MyThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<=10;i++) {
				System.out.println("该时间片段线程名称："+getName()+"  打印出来的数据是："+i);
			}
		}
	}
}

执行结果：

实现Runnable接口

  • Runnable并不是线程；只是通过实现接口配合Thread来创建子线程
  • 查看Thread类源码的run方法，假如没有给传runnable的话，target是null，run方法是不执行的

    @Override

    public void run() {

        if (target != null) {

            target.run();

        }

    }

public class RunnableTest {
	public static void main(String[] args) {
		
		MyRunnable r1=new MyRunnable();
		MyRunnable r2=new MyRunnable();
		MyRunnable r3=new MyRunnable();

		Thread thread=new Thread(r1);
		Thread thread2=new Thread(r2);
		Thread thread3=new Thread(r3);
		
		thread.start();
		thread2.start();
		thread3.start();
		
		Thread thread4=new Thread();
		thread4.start();
		
		System.out.println("main");

	}
	
	static class MyRunnable implements Runnable{

		@Override
		public void run() {
			Thread thread=Thread.currentThread();
			
			for(int i=0;i<=10;i++) {
				System.out.println("该时间片段线程名称："+thread.getName()+"  打印出来的数据是："+i);
			}
		}
		
	}
}

打印结果：

线程的5种状态

（创建、就绪、执行、阻塞、终止）

线程常用方法

sleep（毫秒）使线程进入阻塞，例如我们实现一个显示时间，隔1秒执行功能，可以sleep（1000）
getName（）/setName在run方法中获取线程和设置线程名称
currentThread（）获取当前线程，结合Runnable使用的时候会调用

interrupt（）和

interrupted（）
  1. 打断线程阻塞状态，例如B线程在sleep暂停，A线程打断B线程，B线程会异常
  2. nterrupt打断阻塞，只是根据标识符true或者false的状态进行执行或者停止
  3. interrupted返回true或者false状态进行判断
  4. interrupt()方法只是改变中断状态，它不会中断一个正在运行的线程。调用interrupt()方法只会给线程设置一个为true的中断标志，设置之后，根据线程当前状态判断，然后进行后续操作；
  5. stop()方法强制使线程退出，但是使用该方法不安全，已经被废弃，这是和interrupt的区别
join（）
  1. 当前线程等待被调用的线程结束，再继续执行
  2. thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
yiled（）

当前线程让出CPU资源，主动让给其他线程，不会让线程进入阻塞状态，也就是说让本线程从执行中的状态

又回到就绪的状态，以后甚至马上也可能会继续抢占CPU时间片，继续执行

setPriority()和getPriority()优先级，默认优先级是5，不需要手动改，从1到10，优先级越高，获得的CPU越多
setDaemon(true)设置为后台线程，或者叫守护线程
isAlive()

判断线程的状态

线程处于“新建”状态时，线程调用isAlive()方法返回false。在线程的run()方法结束之前，即没有进入死亡状态之前，线程调用isAlive()方法返回true

  • 多线程设置线程名称和获取名称setName和getName
public class YieldTest {

	public static void main(String[] args) {
		YieldThread t1=new YieldThread("线程1");
		YieldThread t2=new YieldThread("线程2");
		YieldThread t3=new YieldThread("线程3");

		t1.start();
		t2.start();
		t3.start();

	}
	
	static class YieldThread extends Thread{
		public YieldThread(String name) {
			setName(name);
		}
		
		@Override
		public void run() {
			System.out.println(getName());
		}
	}
}

执行结果：

  • interrupt（）
public class InterruptTest {
	public static void main(String[] args) {

		MyThread t1=new MyThread();
		t1.start();
		
		System.out.println("按回车结束线程");
		new Scanner(System.in).nextLine();
		t1.interrupt();
	}
	
	
  static class MyThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<=10;i++) {
				try {
					//每隔1秒钟打印一次
					System.out.println("该时间片段线程名称："+getName()+"  打印出来的数据是："+i);
					sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
					System.out.println("main线程打断了子线程");
				}
			}
		}
	}
}

执行结果：当前秒数内抛异常之后，会继续执行后续线程中的内容

显然，打断之后还一直执行是不对的，进行代码优化，判断线程状态进行停止

public class InterruptTest {
	public static void main(String[] args) {

		MyThread t1=new MyThread();
		t1.start();
		
		System.out.println("按回车结束线程");
		new Scanner(System.in).nextLine();
		
		t1.interrupt();
	}
	
	
  static class MyThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<=10;i++) {
				try {
					
					if(isInterrupted()) {
						break;
					}
					
					//每隔1秒钟打印一次
					System.out.println(getName()+"  "+i+"  "+isInterrupted());
					sleep(1000);
				} catch (InterruptedException e) {
//					e.printStackTrace();
					System.out.println("main线程打断了子线程"+isInterrupted());
					interrupt();
					System.out.println("main线程打断了子线程"+isInterrupted());
				}
			}
		}
	}
}

打印结果：

join（）

  • 比如有两个线程A和B，两个线程都在执行，执行过程中发现，A线程要用到B线程的结果，然后再继续执行，这时候，就需要把并行改成串行，相当于把B线程插入到了A线程中，然后再执行A线程，这时候就需要线程B调用join（）方法，进行插入操作；

 首先做个测试，假如我要求1到10000000之间所有的质数，我们知道，java启动程序会开启main主线程，需要开启子线程的话，需要我们手动去添加，首先上代码

public class JoinTest {

	public static void main(String[] args) throws InterruptedException {
		
		f1();
	}

	private static void f1() throws InterruptedException {
		
		System.out.println("单线程测试质数个数：");
		
		//单线程测试
		long s=System.currentTimeMillis();
		
		JoinThread thread=new JoinThread(1, 10000000);
		thread.start();
		
		int sum=thread.count;
		
		s=System.currentTimeMillis()-s;
		System.out.println("总共"+sum+"个质数，耗时："+s);
	}

	//定义子线程
	static class JoinThread extends Thread{
		int start;
		int end;
		int count;
		
		public JoinThread(int start,int end) {
			this.start=start;
			this.end=end;
			if(start<=2) {
				count=1;
				start=3;
			}
		}
		
		@Override
		public void run() {
			for(int i=start;i<end;i++) {
				if(isZhishu(i)) {
					count++;
				}
			}
		}

		private boolean isZhishu(int i) {
			double max=1+Math.sqrt(i);
			for(int j=2;j<max;j++) {
				if(i%j==0) {
					return false;
				}
			}
			return true;
		}
	}
}

打印结果：

明显是错误的，为什么会这样呢？答案很简单，在子线程还没执行完的时候，main主线程就开始调用了输出语句，获取结果了，所以肯定是错误的，这时候就要用到join方法，main主线程等待子线程执行完再执行，把子线程调用join，插入到main线程

代码块改f1（）方法添加，改成如下：

	private static void f1() throws InterruptedException {
		
		System.out.println("单线程测试质数个数：");
		
		//单线程测试
		long s=System.currentTimeMillis();
		
		JoinThread thread=new JoinThread(1, 10000000);
		thread.start();
		
		thread.join();
		
		int sum=thread.count;
		
		s=System.currentTimeMillis()-s;
		System.out.println("总共"+sum+"个质数，耗时："+s);
	}

这时候打印结果：

结果正确了，但是发现耗时用了6秒多，效率很低，这时候，可以优化，把单线程改成多个子线程：

public class JoinTest {

	public static void main(String[] args) throws InterruptedException {
		
		f5();
	}

	private static void f5() throws InterruptedException {
		
		System.out.println("5个线程测试质数个数：");
		
		//单线程测试
		long s=System.currentTimeMillis();
		
		JoinThread[]threads=new JoinThread[5];
		
		for(int i=0;i<threads.length;i++) {
			threads[i]=new JoinThread(2000000*i,2000000*(i+1));
			threads[i].start();
//			threads[i].join();//千万不要在这里进行join，否则会变成多个子线程串行，和单线程无区别了
		
		
		for(JoinThread joinThread:threads) {
			joinThread.join();
		}
		
		int sum=0;
		for(int i=0;i<threads.length;i++) {
			sum+=threads[i].count;
		}
				
		s=System.currentTimeMillis()-s;
		System.out.println("总共"+sum+"个质数，耗时："+s);// TODO Auto-generated method stub
		
	}


	//定义子线程
	static class JoinThread extends Thread{
		int start;
		int end;
		int count;
		
		public JoinThread(int start,int end) {
			this.start=start;
			this.end=end;
			if(start<=2) {
				count=1;
				start=3;
			}
		}
		
		@Override
		public void run() {
			for(int i=start;i<end;i++) {
				if(isZhishu(i)) {
					count++;
				}
			}
		}

		private boolean isZhishu(int i) {
			double max=1+Math.sqrt(i);
			for(int j=2;j<max;j++) {
				if(i%j==0) {
					return false;
				}
			}
			return true;
		}
	}

运行结果：

  • 后台进程setDaemon(true)

public class daemonTest {

	public static void main(String[] args) {
		
		System.out.println("输入换行停止t1线程：");

		DaemonThread t1=new DaemonThread();
		t1.start();

		Thread t2=new Thread(){
			public void run() {
				new Scanner(System.in).next();
				t1.interrupt();
			};
		};
		
		//一定要写在执行之前
//		t2.setDaemon(true);
		t2.start();
	}
	
	static class DaemonThread extends Thread{
		@Override
		public void run() {
			for(int i=0;i<=5;i++) {
				try {
					System.out.println(i);

					sleep(1000);
				} catch (InterruptedException e) {
					System.out.println("线程异常");
				}
			}
		}
	}
}

执行结果

控制台依然在等待用户输入

假如把t2.setDaemon(true);这句话放开，设置成后台进程，那么线程执行完就会结束，不会等待用户操作了，执行结果如图：

线程同步synchronized

详细请参考下一篇 Java 线程同步

小小苏的小小苏
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java线程的基础知识
luojiawe的博客
05-23 163
java线程的创建方式
Java线程基础
zeo_123的博客
04-03 369
Thread，意为线程，Thread类实现了Runnable接口，重写了里面唯一的run方法，但是里面的run方法由于target属性为null，并没有执行实现了Runnable接口的run方法。这种方式创建线程，需要继承Thread类，然后重写run方法，在run方法里面写上想实现的业务逻辑，这里让其每隔一秒在控制台输出“喵喵叫”，在main方法里实例化Cat对象，调用start方法启动线程。并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。
Java中的线程基础篇-线程基本概念
weixin_44446626的博客
05-08 1795
Java中的线程一、基础知识1. 进程、线程、协程1.1 进程1.2 线程1.3 协程2. 串行、并发、并行2.1 串行2.2 并发2.3 并行二、线程的创建1. 继承Thread类1.1 实现步骤1.2 特点2. 实现Runnable接口2.1 实现步骤2.2 与Thread相比3. 实现Callable接口（JDK5.0新增）3.1 实现步骤3.2 与Runnable接口相比三、线程的常用方法四、线程的生命周期1. 基本概念2. 六个状态 一、基础知识 1. 进程、线程、协程 1.1 进程 基本概念
Java线程基础知识汇总（超详细版）
HSQdePYZ的博客
07-17 669
进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
Java线程基础知识
java之书-资源
04-16 551
java线程基础知识和应用案例
java 线程知识_java多线程知识点总结
weixin_32642653的博客
02-12 131
1.几个基本的概念进程(Process)：一个程序运行起来时在内存中开辟一段空间用来运行程序，这段空间包括heap、stack、data segment和code segment。例如，开一个QQ就表明开了一个QQ进程。线程(Thread)：每个进程中都至少有一个线程。线程是指程序中代码运行时的运行路径，一个线程表示一条路径。例如QQ进程中，发送消息、接收消息、接收文件、发送文件等各种独立的功能都...
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6245
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
java多线程基础知识
01-25
Java多线程基础知识是Java编程语言中的一项重要技术，用于提高程序的执行效率和响应速度。在这里，我们将详细介绍Java多线程基础知识的相关概念和技术。 一、程序、进程和线程 程序（Program）是一段静态的代码，...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java 多线程的基础知识
04-21
java 多线程学习笔记
Java线程并发控制基础知识
12-22
　推荐用ThreadPoolExecutor的工厂构造类Executors来管理线程池，线程复用线程池开销较每次申请新线程小，具体看代码以及注释   public class TestThread { /** * 使用线程池的方式是复用...
Java面试基础知识.doc
11-21
"Java面试基础知识" Java 面试基础知识是 Java 开发者在面试时需要了解的基础知识点。以下是 Java 面试基础知识的重要知识点： 1. Java 的接口和 C++的虚类的雷同和不合处 Java 的接口和 C++ 的虚类有相似之处，...
【java基础】关于线程的一些基础知识点
weixin_62697030的博客
12-28 407
在java的应用中，线程更多情况下指的是Thread，更精细一点，执行线程就是执行Thread实体下面的run方法，java通过cpu调试，交替进行这些thread，就达到了共同进行这种效果；其中，main也被我们称作主线程。线程之间原则上是允许并行进行的，多线程就是同时在执行多个东西。进程（process）包含多个线程，比如说打开视频算是一个进程，视频的音乐，画面，字幕和播放器支持都是线程（thread）
Java的所有线程知识精华全在CompletableFuture了
我是香菜
02-07 8942
java8中的CompletableFuture串联了java中的所有java线程知识
java线程基础知识
weixin_48288539的博客
10-27 250
介绍了java线程的简单使用，java程序对线程状态的调度，以及ThreadLocal的使用和一部分源码理解。
java线程基础
Legolas_PRC的博客
01-31 95
java线程的一些基础知识
java runnable 停止线程_Java中终止线程的方法详解
weixin_42348026的博客
02-13 7924
Java中终止线程的方式主要有三种：1、使用stop()方法，已被弃用。原因是：stop()是立即终止，会导致一些数据被到处理一部分就会被终止，而用户并不知道哪些数据被处理，哪些没有被处理，产生了不完整的“残疾”数据，不符合完整性，所以被废弃。So, forget it!2、使用volatile标志位看一个简单的例子：首先，实现一个Runnable接口，在其中定义volatile标志位，在run(...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1258
Java开发环境配置

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小苏的小小苏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值