Java之线程

最新推荐文章于 2023-10-10 12:40:22 发布
最新推荐文章于 2023-10-10 12:40:22 发布
阅读量312 收藏 1
点赞数
分类专栏： JAVA基础知识学习笔记 文章标签： java eclipse 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zysp158/article/details/124076658
版权

Java之线程

1.线程

实现线程的两种方法：
  • 创建一个Thread类，或者一个Thread子类的对象
  • 创建一个实现Runnable接口的类的对象
Thread类

Thread是一个线程类，位于java.lang包下
Thread类构造方法描述，截图来自慕课网
Thread类的常用方法
Thread类的常用方法，截图来自慕课网

Runnable接口
  • 只有一个方法run();
  • Runnable是Java中用以实现线程的接口
  • 任何实现线程功能的类都必须实现该接口(包括Thread类)
线程创建
通过继承Thread类的方式创建线程类，重写run()方法。
class MyThread extends Thread{
	public void run() {
		System.out.println(getName() + "这个线程正在运行 ！");
	}
}


public class TheadTest {

	public static void main(String[] args) {
	    MyThread mt = new MyThread();
	    mt.start(); // 只能调用一次，线程不能被多次启动

        
	}

}

输出结果：
线程测试程序的输出结果
线程的调用顺序是随机的

class MyThread extends Thread{
    public MyThread(String name) {
        super(name);
    }
	public void run() {
		
		for (int i=1; i<=10; i++) {
			System.out.println(getName() + "这个线程正在运行 ！");
		}
	 
	}
}


public class TheadTest {

	public static void main(String[] args) {
	    MyThread mt1 = new MyThread("线程01");
	    MyThread mt2 = new MyThread("线程02");
	    mt1.start();
	    mt2.start();
	    

	}

}

输出结果：
线程测试程序的输出结果
从程序输出的结果可以看出线程的调用顺序是随机的。

通过实现Runnable接口的方式创建线程类

原因：

  • Java不支持多继承，已经继承了其他类无法再继承线程类
  • 不打算重写Thread类的其他方法
class RunnableTest implements Runnable{
	int i;
	 public void run() {
		 for (i = 1; i<=10; i++) {
				System.out.println(Thread.currentThread().getName() + "这个线程正在运行 ！");
			}
	 }
 }

public class Test {
           
	public static void main(String[] args) {
		RunnableTest rt = new RunnableTest();
	    Thread tr1 = new Thread(rt);
	    tr1.start();
	    Thread tr2 = new Thread(rt); // 如果创建多个线程基于同一个Runnable target，即rt则所有线程共同执行其中的资源。
	    tr2.start();

	}

}

输出结果：
Runnable接口的测试程序的输出结果

线程的状态

线程分为五个状态

  1. 新建(new)
  2. 可运行(Runnable)
  3. 正在运行(Running)
  4. 阻塞(Blocked)
  5. 终止(Dead)
线程的生命周期

![截图来自慕课网](https://img-blog.csdnimg.cn/db7957e26e4b444abfc7ef26486618d2.png?x-oss-p在这里插入图片描述

sleep方法

Thread类的方法

public static void sleep(long millis)

让正在执行的线程休眠指定的毫秒数。

class RunnableTest implements Runnable{
	int i;
	 public void run() {
		 for (i = 1; i<=10; i++) {
				System.out.println(Thread.currentThread().getName() + "这个线程正在运行 ！");
			    if(i == 3) {
			        try {
						Thread.sleep(1500);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
			    }
			}
	 }
 }

public class Test {
           
	public static void main(String[] args) {
		RunnableTest rt1 = new RunnableTest();
	    Thread tr1 = new Thread(rt1);
	    tr1.start();
	    RunnableTest rt2 = new RunnableTest();
	    Thread tr2 = new Thread(rt2);
	    tr2.start();

	}

}

输出结果：
线程休眠的测试程序输出结果

join方法

Thread类的方法

public final void join()
public final void join(long millis)

优先执行调用该方法的线程，等该线程结束之后再执行其他的线程
可以穿入参数，long millis为最长等待时间。

class RunnableTest implements Runnable{
	int i;
	 public void run() {
		 for (i = 1; i<=10; i++) {
				System.out.println(Thread.currentThread().getName() + "这个线程正在运行 ！");
			    
			}
	 }
 }

public class Test {
           
	public static void main(String[] args) {
		RunnableTest rt1 = new RunnableTest();
	    Thread tr1 = new Thread(rt1);
	    tr1.start();
	    try {
			tr1.join();
		} catch (InterruptedException e) {
		 
			e.printStackTrace();
		}
	    RunnableTest rt2 = new RunnableTest();
	    Thread tr2 = new Thread(rt2);
	    tr2.start();

	}

}

输出结果：
程序输出结果

线程的优先级

从数字1到10，越大优先级越高，默认优先级为5。

优先级常量
  • MAX_PRIORITY: 线程的最高优先级10
  • MIN_PRIORITY: 线程的最低优先级1
  • NORM_PRIORITY:线程的默认优先级5
    注：线程优先级高并不一定先执行，具有一定的随机性
public int getPriority()
public void setPriority(int newPriority)

class RunnableTest implements Runnable{
	int i;
	 public void run() {
		 for (i = 1; i<=10; i++) {
				System.out.println(Thread.currentThread().getName() + "这个线程正在运行 ！");
			    
			}
	 }
 }

public class Test {
           
	public static void main(String[] args) {
		RunnableTest rt1 = new RunnableTest();
	    Thread tr1 = new Thread(rt1);
	    
	    RunnableTest rt2 = new RunnableTest();
	    Thread tr2 = new Thread(rt2);
        tr1.setPriority(Thread.MAX_PRIORITY);
	    tr1.start();
	    tr2.start();
	    System.out.println("线程："+tr1.getName()+"的优先级为："+tr1.getPriority());
	    System.out.println("线程："+tr2.getName()+"的优先级为："+tr2.getPriority());
        
	}

}

输出结果：
线程优先级程序测试输出结果

线程同步
synchronized关键字

作用领域：

  • 成员方法
  • 静态方法
  • 语句块
public synchronized void saveAccount(){}
public static synchronized void saveAccount(){}
synchronized (object){}

class RunnableTest implements Runnable{
	int i;
	 public void run() {
		 synchronized(this) {
		
		 for (i = 1; i<=10; i++) {
				System.out.println(Thread.currentThread().getName() + "这个线程正在运行 ！");
			    
			}
		 }
	 }
 }

public class Test {
           
	public static void main(String[] args) {
		RunnableTest rt1 = new RunnableTest();
	    Thread tr1 = new Thread(rt1);
	    
	    RunnableTest rt2 = new RunnableTest();
	    Thread tr2 = new Thread(rt1);
        
	    tr1.start();
	    tr2.start();
     
	}

}

输出结果：
线程同步的测试程序输出结果01
可以看到，相同的对象被锁住，第一个线程执行完成，第二个线程才会执行。
如果对象不同，则锁失效。

class RunnableTest implements Runnable{
	int i;
	 public void run() {
		 synchronized(this) {
		
		 for (i = 1; i<=10; i++) {
				System.out.println(Thread.currentThread().getName() + "这个线程正在运行 ！");
			    
			}
		 }
	 }
 }

public class Test {
           
	public static void main(String[] args) {
		RunnableTest rt1 = new RunnableTest();
	    Thread tr1 = new Thread(rt1);
	    
	    RunnableTest rt2 = new RunnableTest();
	    Thread tr2 = new Thread(rt2);
        
	    tr1.start();
	    tr2.start();
     
	}

}

输出结果：
线程同步的测试程序输出结果02

线程间的通信

方法：

  • wait(): 使线程中断执行，进入阻塞状态
  • notify(): 唤醒某一个等待的线程
  • notifyAll(): 唤醒所有等待的线程
public class Queue {

	private int n;
    Boolean flag = false;

	public synchronized int getN() {
	    if(!flag) {
	        try {
				wait();
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			} 
	    }
		
	     System.out.println("消费:"+n);
	     flag =  false;
	     notifyAll();
		return n;
	}

	public synchronized void setN(int n) {
		if(flag) {
	        try {
				wait();
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			} 
	    }
	    System.out.println("生产:"+n);
	    flag =  true;
	    notifyAll();
		this.n = n;
	}

}

public class Producer implements Runnable {
    Queue queue;
    Producer(Queue queue){
        this.queue= queue;
    }
	@Override
	public void run() {
        int i=0;
        while(true) {
             queue.setN(i++);
             try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			}
        }
		

	}

	

}

public class Consumer implements Runnable {
	Queue queue;
    Consumer(Queue queue){
        this.queue= queue;
    }

	@Override
	public void run() {
		int i=0;
        while(true) {
             queue.getN();
             try {
 				Thread.sleep(1000);
 			} catch (InterruptedException e) {
 				
 				e.printStackTrace();
 			}
        }
		

	}

}

public class Test {

	public static void main(String[] args) {
         Queue queue=new Queue();
         new Thread(new Producer(queue)).start();
         new Thread(new Consumer(queue)).start();
		

	}

}

输出结果：
线程间的通信输出结果

咖啡，巫师与猫
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
JAVA线程
互联网底层民工的博客
06-26 7322
虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock，Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化。
java 线程详解
muranfei的博客
07-02 1万+
一、线程的基本概念 一个线程就是在进程中的一个单一的顺序控制流. 而单个进程可以拥有多个并发执行的任务，每个任务都好像有自己的CPU一样，而其底层的机制就是切分CPU的时间，也就是CPU将轮流给每个任务分配其占用时间。 每个任务都觉得自己在一直占用CPU，而事实上是将CPU时间划分成片段分配给所有的任务。 在多个CPU的环境下，多线程的运作，可以极大的提供程序的运行速度，这就是线程存在的意...
Java线程系列详解
wang_yong_hui_1234的博客
04-15 2975
1）volatile本质是在告诉jvm当前变量在寄存器中的值是不确定的，需要从主存中读取，synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。2）volatile仅能使用在变量级别，synchronized则可以使用在变量，方法。3）volatile仅能实现变量的修改可见性，而synchronized则可以保证变量的修改可见性和原子性。4）volatile不会造成线程的阻塞，而synchronized可能会造成线程的阻塞。
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6205
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
编程必备：JAVA多线程详解
拾一二的博客
06-14 6893
多线程已经成为一种常见的编程模式，广泛应用于各种不同类型的应用程序中。本篇博客文章中，我们将会探讨多线程编程的相关知识和技巧。通过代码示例和实际应用案例来深入了解多线程的具体实现和应用方法，帮助更好地掌握多线程编程技术，提高程序效率和性能。后期随学习深入还会补充修改。以上就是我对多线程的个人简介，后续会不断完善更新，与大家共勉。
Java多线程编程总结
01-31
下面的内容是很早之前写的，内容不够充实，而且是基于Java1.4的内容，Java5之后，线程并发部分扩展了相当多的内容，因此建议大家看上面的系列文章的内容，与时俱进，跟上Java发展的步伐。要认识多线程就要从操作系统...
java 多线程
11-07
java 多线程 知识相关，主要是介绍 java 多线程相关的知识
Java线程
12-21
目录 理解线程的概念 ... 在Java中，每次程序运行至少启动2个线程：一个是main线程，一个是垃圾收gc集线程。每当使用java命令执行一个类的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启
java多线程实现动画
12-20
java 多线程实现动画控制
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 7253
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
Java创建线程的七种方法，全网最全面总结~
CYK_byte的博客
02-03 2万+
属于基础的面试问题，一定要能够回答全哦~
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
Java基础学习——Java线程（一）多线程的发展史、线程的三种创建方式、线程的生命周期、线程的常用方法、线程的优先级
skx1102195517的博客
12-27 1096
一、什么是线程 1.概念 1）程序：为完成特定任务，用某种语言编写的一组指令的集合（程序是静态的） 2）进程：是程序的一次执行过程。进程作为分配资源的单位，在内存中为每个正在运行的进程分配不同的内存区域（进程是动态的），进程有生命周期。 3）线程： 一个进程同时执行多个线程，就是多线程。 2.单核CPU与多核CPU 对于在单核CPU上执行的多个线程，CPU按照时间片执行，一个时间片只能执行一个线程，但时间片时间特别短，造成了同时执行多个线程的假象。 多核CPU才真正实现了同一时间多个线程同时
Java线程详解
boilll的博客
11-29 715
自学笔记，自用
java多线程（超详细）
热门推荐
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java线程、Java多线程详细介绍
Doreamonx的博客
06-13 1699
Java线程
java前台线程后台线程
最新发布
02-28
在Java中，线程可以分为前台线程和后台线程。 前台线程（也称为用户线程）是指由用户创建并控制的线程。当所有的前台线程都执行完毕时，Java虚拟机会退出。前台线程通常用于执行一些重要的任务，例如处理用户输入、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值