Java---线程详解

最新推荐文章于 2024-06-04 10:12:53 发布
最新推荐文章于 2024-06-04 10:12:53 发布
阅读量560 收藏 2
点赞数 2
分类专栏： java语法 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaoqiandr/article/details/128275263
版权

目录

一、线程的介绍

二、线程的使用

（1）多线程的实现

1：继承Thread类

2：实现Runnable接口

（2）设置和获取线程名称

1:继承Thread类

2：实现Runnable接口

（3）线程的优先级

（4）线程的控制

1：sleep方法

2：join方法

3：setDaemon方法

三、线程安全 

一、线程的介绍

线程是进程中的单个顺序控制流，是一条执行路径。说得简单点吧，比如说扫雷这个游戏，有一个线程是扫雷，有一个程序是计时，可这个计时并不是直接计时，它是等开始扫雷时才进行，其实我说的意思就是计时是一个程序，扫雷是一个程序，但他们是单独的程序，他们每一个程序其实就是一个线程。（个人理解的补充：在后面他执行的时候其实就是要拿到CPU的执行权，但一般电脑都是只有一个CPU吧，多个线程去抢，谁抢到了，就执行哪个线程）
单线程：一个进程中如果只有一条执行路径，就是单线程程序
多线程：一个进程中如果有多条执行路径，则称为多线程程序
 

二、线程的使用

（1）多线程的实现

多线程的实现方式有两种
1：继承Thread类
2：实现Runnable接口


1：继承Thread类（要重写Thread类中的run方法，并使用start方法启动线程）

//这是继承类
public class mythread extends Thread{
   public void run() {
	   for(int i=1;i<20;i++) {
		   System.out.println(i);
	   }
   }
}

//这是测试类
public class test {
   public static void main(String[] args) throws UnknownHostException {
	  mythread m1=new mythread();
	  mythread m2=new mythread();
	  m1.start();
	  m2.start();
   }
}

2：实现Runnable接口


public class mythread implements Runnable{
   public void run() {
	   for(int i=1;i<20;i++) {
		   System.out.println(i);
	   }
   }
}

//测试类

public class test {
   public static void main(String[] args) throws UnknownHostException {
	    mythread m=new mythread();
	    Thread m1=new Thread(m);
	    Thread m2=new Thread(m);
	    
	    m1.start();
	    m2.start();
   }
}

（2）设置和获取线程名称

1:继承Thread类


public class thread extends Thread{
   public void run() {
	   for(int i=0;i<10;i++) {
		   System.out.println(Thread.currentThread().getName()+":"+i);
	   }
   }
}

public class test {
   public static void main(String[] args) throws UnknownHostException {
	  thread m1=new thread();
	  thread m2=new thread();
	  m1.setName("ioi");
	  m2.setName("opopop");
	  
	  m1.start();
	  m2.start();
	  
   }
}

 

2：实现Runnable接口

public class mythread implements Runnable{
   public void run() {
	   for(int i=1;i<20;i++) {
		   System.out.println(Thread.currentThread().getName()+":"+i);
		   
	   }
   }
}


public class test {
   public static void main(String[] args) throws UnknownHostException {
	   mythread m=new mythread();
	   Thread m1=new Thread(m,"高铁");
	   Thread m2=new Thread(m,"飞机");
	   
	   System.out.println("第一="+m1.getName());
	   System.out.println("第二="+m2.getName());
	   m1.start();
	   m2.start();
	   
   }
}

（3）线程的优先级

Java使用的线程调度是抢占式调度模型，抢占式调度模型就是优先让优先级高的使用CPU，如果线程的优先级相同，那么随机一个，优先级高的线程获取的CPU时间片相对多一些。

假如计算机只有一个CPU，那么CPU在某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。
所以说多线程程序的执行是有随机性的，因为谁抢到CPU的使用权是不一定的。

注意哈，优先级高并不一定是它先执行，它只是加大了可以拿到CPU权限的概率而已


Thread类中设置和获取线程优先级的方法
（1）public final int getPriority()   返回此线程的优先级
（2）public final void setPriority()  更改此线程的优先级
public class test {
   public static void main(String[] args) throws UnknownHostException {
	  thread m1=new thread();
	  thread m2=new thread();
	  
	  m1.setName("高铁");
	  m2.setName("飞机");
	  m1.setPriority(3);
	  m2.setPriority(8);
	  System.out.println("第一个线程的="+m1.getPriority());
	  System.out.println("第二个线程="+m2.getPriority());
	  m1.start();
	  m2.start();
   }
}

（4）线程的控制

1：sleep方法

public class thread extends Thread{
   public void run() {
	   for(int i=0;i<10;i++) {
		   System.out.println(Thread.currentThread().getName()+":"+i);
		   try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	   }
   }
}
//test类正常使用就行

2：join方法

public class test {
   public static void main(String[] args) throws UnknownHostException {
	  thread m1=new thread();
	  thread m2=new thread();
	  thread m3=new thread();
	  
	  m1.setName("高铁");
	  m2.setName("飞机");
	  m3.setName("公交");
	  
	  
	  m1.start();
//等m1这个线程死亡之后，后面的线程开始抢夺CPU的执行权限
	  try {
		m1.join();
	} catch (InterruptedException e) {
		// TODO 自动生成的 catch 块
		e.printStackTrace();
	}
	  m2.start();
	  m3.start();
   }
}

 

3：setDaemon方法

该方法用来开启守护线程，守护线程的作用就是和主线程同生共死，但是主线程结束之后，守护线程不会立即死亡，而是会挣扎几下才会死亡哦

public class test {
   public static void main(String[] args) throws UnknownHostException {
	  thread m1=new thread();
	  thread m2=new thread();
	  
	  m1.setName("高铁");
	  m2.setName("飞机");
	  
	  Thread.currentThread().setName("我是主线程");
	  m1.setDaemon(true);
	  m2.setDaemon(true);
	  
	  m1.start();
	  m2.start();
	  for(int i=0;i<10;i++) {
		  System.out.println(Thread.currentThread().getName()+":"+i);
	  }
   }
}

三、线程安全 

假如给你一个案列：A,B,C三个窗口卖票，票数是100张，每次顾客来买票时，票数减一，并且在控制台输出是哪一个窗口卖出的票，和当前正在出售第几张票。

如果按照正常使用线程解决该题的话，也就是如下的代码：

public class mythread implements Runnable{
	private int ticket=100;
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		while(true) {
			if(ticket>0) {
				//票数大于0，，也就是有票的情况
				try {
					Thread.sleep(100);//休眠0.1秒
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
				ticket--;
			}
		}
	}
}
public class test {
   public static void main(String[] args) throws UnknownHostException {
	  mythread m=new mythread();
	  Thread s1=new Thread(m,"A");
	  Thread s2=new Thread(m,"B");
	  Thread s3=new Thread(m,"C");
	  
	  s1.start();
	  s2.start();
	  s3.start();
   }
}

 看到上面你会发现怎么出现了-1呢？

在其中假如a抢到了CPU的执行权限进入if分支，后面遇到休眠。在休眠
的这段时间内b又抢到了CPU的执行权限进入分支，进入休眠，假如这时候
a醒来后执行操作，输出，并将票数-1，假如此时票数已经是0了，后面判断
票数自然无法进入if分支了，但是如果，之前就在if分支里但是是在休眠就可以
再次进行输出和票数减一了

那么该如何解决呢？这时候就需要用到同步代码块了

public class mythread implements Runnable{

	private int ticket=100;
	private Object obj=new Object();
	@Override
	public void run() {
		// TODO 自动生成的方法存根
		
		while(true) {
		  synchronized (obj) {//同一把锁
			if(ticket>0) {
				//票数大于0，，也就是有票的情况
				
				try {
					Thread.sleep(100);//休眠0.1秒
				} catch (InterruptedException e) {
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
				ticket--;
			}
		}
		}
			
	}
   
}

菜到极致就是渣
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java线程详解
boilll的博客
11-29 760
自学笔记，自用
Java线程系列详解
wang_yong_hui_1234的博客
04-15 3949
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
如何理解 Java 线程的概念及线程的创建和管理，包括 Runnable 接口和 Thread 类
最新发布
Itmastergo的博客
06-04 964
多线程编程是现代软件开发中的重要技术，能够显著提高程序的效率和响应速度。Java 提供了丰富的多线程编程支持，使开发者可以轻松地创建和管理线程。
Java线程基础知识汇总（超详细版）
HSQdePYZ的博客
07-17 692
进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
编程必备：JAVA多线程详解
拾一二的博客
06-14 7882
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java-并发-Java线程中断与停止线程详解
12-22
  Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。即“线程中断”并不是字面意思——线程真的中断了，而是设置了中断标志...
Java资料-详解ThreadLocal
06-16
`ThreadLocal`在Java中是一个非常重要的工具类，它为每个线程提供了单独的变量副本，每个线程都可以独立地改变自己副本的值，而不会影响其他线程所对应的副本。`ThreadLocal`的全称是`java.lang.ThreadLocal`，它并...
JAVA IO-NIO 详解
04-24
传统的Java IO是阻塞式的，即当程序进行读写操作时，如果数据没有准备好，线程会阻塞等待，这在高并发场景下会导致线程资源的浪费。而NIO则是非阻塞式的，它允许线程在等待数据准备好的同时，继续执行其他任务，从而...
详解Java线程-守护线程与用户线程
08-26
"Java守护线程与用户线程详解" Java中的线程可以分为守护线程(DaemonThread)和用户线程(UserThread)两类。守护线程和用户线程的唯一区别是它们对虚拟机的退出(程序的终止)的影响。 当JVM中只有守护线程时，虚拟机会...
java多线程Thread-per-Message模式详解
08-27
在Java多线程编程中，Thread-per-Message模式是一种常见的并发处理策略。这种模式的核心思想是为每个消息或任务创建一个新的线程来处理，使得消息的发送者和处理者不在同一个线程上下文中运行，从而实现任务的异步...
java多线程详解（比较详细的阐述了多线程机制）
04-21
挺不错的多线程教材，讲得非常详细，希望大家喜欢
深入理解Java多线程（一）
热门推荐
qq_37438740的博客
08-11 4万+
关于java多线程的概念以及基本用法：java多线程基础 1，停止线程 停止线程意味着在线程执行完之前停止正在做的操作，即立刻放弃当前的操作，这并不容易。停止线程可以用Thread.stop()方法，但是这个方法不安全，所以不建议使用，还有一个方法就是Thread.interrupt()方法，但是这个方法不会终止一个正在运行的线程，需要添加一个判断才可以完成线程的停止 1.1，...
Java 多线程详解（三）
wei_zhi的博客
10-13 1031
一、线程的同步与死锁1、线程同步问题的引出所谓的同步问题指的是多个线程操作同一资源时所带来的安全性问题。例如，下面模拟一个简单的卖票程序，要求有5个线程，卖6张票。package com.wz.threaddemo;class MyThread implements Runnable { private int ticket = 6; @Override public void
Java多线程详解
fancky58的博客
03-08 3729
线程基本概念 线程是一个程序内部的顺序控制流 也就是说线程是一个程序里不同的执行路径，理解这个概念就足够了。 线程和进程的区别 每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销。 线程可以看成轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换开销小。 多进程：操作系统能同时运行多个任务（程序）。 多线程：在同一个应用...
java多线程总结：原理结合源码详细讲解 - 简单实用
清风明月独相伴
08-09 1万+
执行策略：线程执行的方式 串行执行 比如：医院给病人看病的时候，可以让所有的病人都拍成一个队形，让一个医生统一的看病。医生：线程。病人看病：任务 这种一个医生给一群站好队形的病人看病--映射到java就相当于：单线程串行执行任务 映射到我们java中的话就相当于线程执行任务。 串行执行的缺点很明显。 例如：就是假设前面有一个病人非常的慢，是一个话唠，本来就是一个小感冒，就和医生唠了一天...
java多线程全面详解
alan_liuyue的博客
03-08 7687
多线程是什么？为什么要用多线程？ 　　介绍多线程之前要介绍线程，介绍线程则离不开进程。 　　首先 ， 进程 ：是一个正在执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元； 　　线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。一个进程中至少有一个进程。 多线程：一个进程中不只有一个线程。 　 为什么要用多线...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菜到极致就是渣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值