Java之多线程加强(多线程调度与控制)

最新推荐文章于 2023-01-27 12:10:33 发布
最新推荐文章于 2023-01-27 12:10:33 发布
阅读量729 收藏
点赞数
分类专栏： Java之线程 Java从入门到高级编程 文章标签： 多线程 java Thread runnable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuosixiaonengshou/article/details/72617017
版权

Java基础知识学了好久了，今天再拿来复习一下。

helloworld

先来一个helloworld热热身

Test.java

package cn.hncu.thread.hello;

public class Test {

	public static void main(String[] args) {
		MyThread mt1=new MyThread(0);//偶数
		MyThread mt2=new MyThread(1); //奇数
		mt1.start();
		mt2.start();
		
		MyRun mr1=new MyRun(50);
		Thread t3=new Thread(mr1);
		MyRun mr2=new MyRun(51);
		Thread t4=new Thread(mr2);
		t3.start();
		t4.start();
	}

}

MyThread.java 

package cn.hncu.thread.hello;

public class MyThread  extends Thread{
	Integer first;
	 public MyThread(Integer first) {
		this.first=first;
	}
	@Override
	public void run() {
		for(int i=first;i<50;i+=2){
			System.out.print(i+" ");
		}
		System.out.println();
	}
	
}

MyRun.java 

package cn.hncu.thread.hello;

public class MyRun implements Runnable{
	Integer first;
	public MyRun(Integer first) {
		this.first=first;
	}
	@Override
	public void run() {
		for(int i=first;i<100;i+=2){
			System.out.print(i+" ");
		}
		System.out.println();
	}
	
}

new出来了四个线程跑跑


多线程调度与控制

这里将通过四个版本代码来演示多线程调度与控制

v1版本

★ Java的多线程是抢占式的运行方式。 ★ setPriority()

★ sleep()方法

Thread类的sleep()方法对当前线程操作，是静态方法。sleep()的参数指定以毫秒为单位的线程休眠时间。除非因为中断而提早恢复执行，否则线程不会在这段时间之前恢复执行。

★ interrupt()方法

一个线程可以调用另外一个线程的interrupt()方法，这将向暂停的线程发出一个InterruptedException。变相起到唤醒暂停线程的功能。Thread类的方法interrupt()，是一种强制唤醒的技术。

Schedule.java 

package cn.hncu.thread.schedule.v1;

public class Schedule {

	public static void main(String[] args) {
		MyThread t1=new MyThread(0);
		MyThread t2=new MyThread(1);
		//setPriority() 相对调度
		//t1.setPriority(5);
		//t2.setPriority(6);
		
		t1.start();
		//t1.start();  //如果一个线程已经启动，再次启动会出异常java.lang.IllegalThreadStateException
		t2.start();
		//唤醒别人
		t1.interrupt(); //mian 线程强制唤醒t1，如果t1正在sleep,那么就停止sleep,往后继续执行代码
	}

}

MyThread.java 

package cn.hncu.thread.schedule.v1;

public class MyThread extends Thread{
	private Integer first;
	public MyThread(Integer first) {
		this.first=first;
	}
	@Override
	public void run() {
		if(first==0){
			try {
				Thread.sleep(1000); //主动睡1000毫秒=1s
			} catch (InterruptedException e) {
				System.out.println("我被强制唤醒了.......要继续干活了");
			}
		}
		for(int i=first;i<50;i+=2){
			System.out.print(i+" ");
		}
		System.out.println();
	}

	
}


v2版本

★ yield()方法

用来使具有相同优先级的线程获得执行的机会。如果具有相同优先级的其它线程是可运行的，yield()将把线程放到可运行池中并使另一个线程运行。如果没有相同优先级的可运行线程，则什么都不做。

注意，执行一次yield()方法，该线程只是放弃当前这一次机会，然后又会重新和其它线程一起抢占CPU，很可能又比其它线程先抢到。

★ join()方法

调用某线程的该方法，将当前线程与该线程“合并”，即等待该线程结束，再恢复当前线程的运行。它可以实现线程合并的功能，经常用于线程的绝对调度。

Schedule.java 

package cn.hncu.thread.schedule.v2;

public class Schedule {

	public static void main(String[] args) {
		MyThread t1=new MyThread(0);
		MyThread t2=new MyThread(1);
		//setPriority() 相对调度
		t1.setPriority(6);
		t2.setPriority(6);
		
		t1.start();
		try {
			t1.join(); //把t1线程剩下的代码合并到当前线程来执行。即：把t1线程中剩下的代码在此处先执行完，再执行后面的代码
		} catch (InterruptedException e) {
			System.out.println("线程合并异常.....");
		}
		t2.start();
	}

}

MyThread.java 

package cn.hncu.thread.schedule.v2;

public class MyThread extends Thread{
	private Integer first;
	public MyThread(Integer first) {
		this.first=first;
	}
	@Override
	public void run() {
		//if(first==0)
			//yield(); //主动让一次，且把机会让给其他同优先级的线程，否则什么也不做
		for(int i=first;i<50;i+=2){
			System.out.print(i+" ");
		}
		System.out.println();
	}

	
}

v3版本

★ wait()方法

当前线程进入对象的waitpool。

★notify()/notifyAll()方法

唤醒对象的waitpool中的一个/所有等待线程。

★suspend()、resume()和stop()这几个方法现在已经不提倡使用。

Schedule.java 

package cn.hncu.thread.schedule.v3;

public class Schedule {

	public static void main(String[] args) {
		Object obj=new Object();
		MyThread t1=new MyThread(0,obj);
		MyThread t2=new MyThread(1,obj);
		t1.start();
		t2.start();
	}

}

MyThread.java 

package cn.hncu.thread.schedule.v3;

public class MyThread extends Thread{
	private Integer first;
	private Object obj;
	private static boolean isWait=true;
	public MyThread(int first, Object obj) {
		this.first=first;
		this.obj=obj;
	}
	@Override
	public void run() {
		synchronized(obj){
			for(int i=first;i<50;i+=2){
				if(first==1&&i>25&&isWait){
					isWait=false;
					try {
						obj.wait();
					} catch (InterruptedException e) {
						System.out.println("被唤醒了.......");
					}
				}
					
				System.out.print(i+" ");
			}
			System.out.println();
			if(first==0){
				isWait=false; //为防止0线程先行拿到锁执行完毕以后，1线程一直wait
				obj.notify(); //只通知那些和自己处于同一等待池中的线程(被同一对象锁困住),任选一个
				//obj.notifyAll();//唤醒池中所有等待的线程
			}
		} //还锁
	}
}


v4版本

Schedule.java

package cn.hncu.thread.schedule.v4;

public class Schedule {

	public static void main(String[] args) {
		MyRun r=new MyRun();
		Thread t1=new Thread(r);
		Thread t2=new Thread(r);
		t1.start();
		t2.start();
	}

}

MyRun.java 

package cn.hncu.thread.schedule.v4;

public class MyRun implements Runnable{
	private boolean isWait=true;
	@Override
	public void run() {
		synchronized(this){
			for(int i=0;i<100;i+=2){
				if(i>50&&isWait){
					isWait=false;
					try {
						wait(); //会释放锁
					} catch (InterruptedException e) {
						System.out.println("被唤醒了....");
					}
				}
				System.out.print(i+" ");
			}
			System.out.println();
			notify();
		} //还锁
	}
	
}

一个线程跑到50就等待，另外一个线程开始跑



线程互斥加强(互斥锁)


★带互斥的共享栈

      多线程互斥共享“栈”资源

Client.java 

package cn.hncu.thread.shareStack;

public class Client {
	
	public static void main(String[] args) {
		MyStack ms=new MyStack();
		PushThread push=new PushThread(ms);
		PopThread pop=new PopThread(ms);
		push.start();
		pop.start();
	}
}

MyStack.java 

package cn.hncu.thread.shareStack;

public class MyStack {
	int idx=0;
	char data[]=new char[6];
	public void push(char ch){
		//同步块  对象直接指定
		synchronized(this){ //用this当对象锁
			data[idx++]=ch;
			System.out.println("push :"+ch);
			this.notify();
		}
	}
	//同步方法: 对象锁是该方法的拥有者  ---静态方法是类，非静态方法是this对象
	public synchronized char pop(){ //this对象锁
		if(idx<1){
			try {
				wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("pop :"+data[--idx]);
		return data[idx];
	}
}

PushThread.java 

package cn.hncu.thread.shareStack;

public class PushThread extends Thread{
	private MyStack stack;
	public PushThread(MyStack stack) {
		this.stack=stack;
	}
	@Override
	public void run() {
		for(int i=65;i<70;i++){
			stack.push((char) i);
		}
	}
	
}

PopThread.java 

package cn.hncu.thread.shareStack;

public class PopThread extends Thread{
	private MyStack stack;
	public PopThread(MyStack stack) {
		this.stack=stack;
	}
	@Override
	public void run() {
		for(int i=65;i<70;i++){
			stack.pop();
		}
	}
	
}

★多窗口卖票

      多线程互斥共享“基本数据类型数据”资源

版本一

TicketSale.java

package cn.hncu.thread.ticket.v1;

public class TicketSale {

	public static void main(String[] args) {
		//开四个窗口 让它们都开始卖票(启动线程)
		TicketWindow tw=new TicketWindow("窗口 ");
		
		Thread t1=new Thread(tw);
		Thread t2=new Thread(tw);
		Thread t3=new Thread(tw);
		Thread t4=new Thread(tw);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}

}

TicketWindow.java 

package cn.hncu.thread.ticket.v1;

public class TicketWindow implements Runnable {
	private Integer num = 200; // 共享变量(基本数据类型的数据) 不能当对象锁---因为他不是对象
	private Object obj = new Object();// 可以新建一个与基本数据类型共享变量平行的对象，来替代它当锁
	private String name;

	public TicketWindow(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		synchronized (obj) { // 拿锁--对象锁
		// synchronized(this){ //直接用this作对象锁也是可以的----非静态变量的对象锁是可以用this替代
			while (true) {
				if (num> 0) {
					System.out.println(name +": " + num);
					num--;
				}else{
					break;
				}
			}
		}//解锁---还锁
	}
}
//非静态变量要当对象锁时，直接用this代替(不需要再另外造对象),无论该变量是否为对象

版本二

TicketSale.java

package cn.hncu.thread.ticket.v2;

public class TicketSale {

	public static void main(String[] args) {
		//开四个窗口 让它们都开始卖票(启动线程)
		
		Thread t1=new Thread(new TicketWindow("窗口1 "));
		Thread t2=new Thread(new TicketWindow("窗口2 "));
		Thread t3=new Thread(new TicketWindow("窗口3 "));
		Thread t4=new Thread(new TicketWindow("窗口4 "));
		t2.start();
		t1.start();
		t4.start();
		t3.start();
	}

}


TicketWindow.java 

package cn.hncu.thread.ticket.v2;

public class TicketWindow implements Runnable {
	private static Integer num = 200; // 共享变量(基本数据类型的数据) 不能当对象锁---因为他不是对象
	private static Object obj = new Object();// 可以新建一个与基本数据类型共享变量平行的对象，来替代它当锁
	private String name;

	public TicketWindow(String name) {
		this.name = name;
	}

	@Override
	public void run() {
		while(true){
			synchronized (obj) {//※静态变量的对象锁是不能用this来代替的
				if (num > 0) {
					System.out.println(name + ":" + num);
					num--;
				} else {
					break;
				}
			}
		}
	}
}

两个版本一个用了非静态变量作锁，一个用了静态变量作锁，两者还是有差别的。


D灿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程的调度_动力节点Java学院整理
08-30
有多个线程，如何控制它们执行的先后次序呢？下文给大家分享四种方法及java多线程调度的实例代码，需要的朋友参考下吧
Java 线程调度
qq_45437885的博客
03-29 1299
Java 线程调度
多线程重点知识归纳总结。
yzh2776680982的博客
06-08 1903
一、线程相关概念 1、程序 程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码 它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。 2、进程 ............
关于多线程的一些小知识
一只仰望天空的菜鸟
07-08 2251
1.线程是操作系统能运行调度的最小单位，是进程的子集。 2.不同线程使用不同的内存空间，而所有的线程共享一片相同的内存空间。 3.创建线程的目的是为了建立程序单独执行路径，让大部分代码实现同时执行。 4.当执行线程的任务结束了，线程自动在栈内存中释放出来，当所有的线程都结束时，进程才算结束。 5.jvm启动后，必然有一个执行路径（线程）mian方法开始的，一直执行到main方法结束，这个线...
java线程调度
weixin_45966674的博客
11-13 1191
我们可以看到 优先级最低的轮渡 确实是最后跑完的 不过还是要强调 优先级高只代表获得CPU 的几率大 不代表是完全按优先级执行的。2 抢占式调度模型: 优先让优先级更高的线程使用CPU，如果线程优先级相同 那机会随机分配优先级 给优先级高的线程更多一些的时间片。然后测试类 通过customException继承的Thread类 给三个线程定义名称 然后开启了三个线程。然后我们注释掉线程启动的代码 然后用getPriority输出一下线程的优先级。
三十. JAVA线程调度机制与应用
DogLee奋斗屋
01-27 853
说到并发，离不开线程这个概念，在操作系统层面有线程，在JAVA进程层面也有线程。同时还知道线程既可以共享进程资源，又可以被独立调度，那么JAVA进程的线程，也肯定存在一种调度机制。本篇文章将对操作系统的线程的三种实现方式进行说明，然后再对JAVA线程的实现方式进行阐述，最后针对JAVA线程的调度机制进行解释并结合例子说明JAVA线程调度机制的应用。
java多线程并发executorservice(任务调度)类
09-04
主要介绍了线程并发ScheduledExecutorService类，设置 ScheduledExecutorService ，2秒后，在 1 分钟内每 10 秒钟蜂鸣一次
基于java swing的多线程电梯调度模拟
05-12
操作系统多线程的作业，模拟多个电梯的调度机制。使用jdk11开发环境。
java多线程导出excel（千万级别）优化
12-05
轻松解决普通poi形式导出Excel的中出现的栈溢出问题，此资源可实现千万级数据分批导出csv文件，csv大数据量导出(千万级别，不会内存溢出)，多线程导出 ，生产环境已经很稳定的使用着
92道Java多线程与并发面试题含答案（很全）
最新发布
01-03
Java并发编程的核心概念包括： 线程（Thread）：线程是程序执行流的最小单元。...原子操作（Atomic Operations）：原子操作是不可中断的操作，即在多线程环境中，这些操作要么完全执行，要么完全不执行。
线程调度与线程控制
qq_45934088的博客
06-06 130
/** 获取默认优先级 默认优先级为5 注意: 线程优先级范围是1-10 public final int getPriority()返回对象的优先级 如何设置线程对象的优先级呢？ public final void setPriority(int newPriority)//更改线程优先级 */ //线程的调度 public class ThreadPriorityDemo { public static void main(String[] args) { ThreadPriority t
JAVASE学习笔记 多线程中的线程调度与线程控制
qq_41537102的博客
01-26 408
目录1.线程调度2.线程控制2.1 线程控制之休眠线程2.2 线程控制之守护线程 多线程中的线程调度与线程控制是使用多线程的常见的操作，掌握这些对于我们使用多线程更加有帮助。 1.线程调度 假如我们的计算机只有一个CPU,那么CPU在某一个时刻只能执行某一条指令。线程是并发的，只有抢到CPU时间片， 也就是使用权，才可以执行命令。那么Java是如何对线程进行调度的呢? 在Java中是通过调度模型（抢占式调度模型）来进行线程调度的。 有两种调度模型：分时调度模型与抢占式调度模型。 两种调度模型 模型
thread类使用笔记
代码人生
01-06 963
前言         C++98/03不支持多线程编程，所以必须借助第三方库（如pthreads、boost::thread）或者目标操作系统中的多线程API（如Windows）。自C++11开始包含了一个标准的多线程库，使编写跨平台的多线程应用程序变得更加容易了。         使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新
java线程同步的原因_学习多线程 造成线程不同步的原因 数组实现简单的栈 三...
weixin_39640372的博客
02-26 84
java代码package com.baigu.demo1.stack;public class TestStack {public static void main(String[] args) throws InterruptedException {Stack stack = new Stack();// stack.print();// stack.posh('...
java多线程 —— 两种实际应用场景模拟
weixin_34351321的博客
08-21 181
最近做的偏向并发了，因为以后消息会众多，所以，jms等多个线程操作数据的时候，对共享变量，这些要很注意，以防止发生线程不安全的情况。 （一） 先说说第一个，模拟对信息的发送和接收。场景是这样的： 就像笔者之前做的消息的发送，一个是服务器，一个是客户端。发送的话，要保证信息100%的发送给客户端，那么发给客户端之后，客户端返回一个消息告诉服务器，已经收到。当服务器一直没有收到客户端返回的消息，...
netty 三之消息推送和心跳检测
w450093854的专栏
11-10 632
主要参考 https://blog.csdn.net/coder_py/article/details/73441043 有小改动（因使用的是netty4的包 netty-all-4.1.25.Final.jar） 通讯信息的基类，需要实现序列化，定义了信息的类型和客户端ID，方便进行管理 消息基类： public abstract class BaseMsg implements S...
Java线程： 线程调度
weixin_34311757的博客
12-21 253
　　线程调度是Java多线程的核心，只有好的调度，才能充分发挥系统的性能，提高程序的执行效率。 一、休眠 　　休眠的目的是使线程让出CPU的最简单做法，线程休眠的时候，会将CPU交给其他线程，以便轮换执行，休眠一定时间后，线程会苏醒，进入准备状态等待执行。线程的休眠方法是Thread.sleep(long millis)和Thread.sleep(lon...
Java多线程的调度策略
try to do
03-16 1099
https://blog.csdn.net/wangyangzhizhou/article/details/41122385 在Java多线程环境中，为保证所有线程的执行能按照一定的规则执行，JVM实现了一个线程调度器，它定义了线程调度的策略，对于CPU运算的分配都进行了规定，按照这些特定的机制为多个线程分配CPU的使用权。这小节关注线程如何进行调度，了解了java线程调度模式有助于后面并发框架的...
深入理解JVM-Java线程-实现方式，线程调度，状态
热门推荐
nalanmingdian的博客
08-31 1万+
Java线程并发并不一定依赖多线程，但Java里谈论并发大多数都与线程脱不开关系。 线程是比进程更轻量级的调度执行单位，线程的引入可以把一个进程的资源分配和执行调度分开，各个线程既可以共享进程资源(内存地址，文件IO等)，又可以独立调度（线程是CPU调度的基本单位）。 Thread类的所有关键方法都声明了native的，意味着这个方法没有使用或无法使用平台无关的手段来实现，也有可能是为了执行效率
java的线程调度器_Java的多线程任务调度示例
06-09
Java的线程调度器是负责管理和分配CPU时间片的组件。它可以帮助我们实现多线程任务的调度，以达到高效利用CPU资源的目的。 以下是一个简单的Java多线程任务调度示例： ```java import java.util.Timer; import java.util.TimerTask; public class TaskScheduler { public static void main(String[] args) { Timer timer = new Timer(); timer.schedule(new MyTask(), 0, 1000); } static class MyTask extends TimerTask { @Override public void run() { System.out.println("执行任务..."); } } } ``` 这个示例中创建了一个Timer对象，并且调用其schedule方法来安排一个定时任务。这个定时任务是由MyTask类实现的，它继承了TimerTask类并重写了其中的run方法。在run方法中，我们可以编写需要执行的任务代码。在本例中，我们简单地输出一条信息。 在调用schedule方法时，需要传入三个参数：要安排的任务、任务第一次执行的时间、任务执行的间隔时间。在本例中，我们设置了任务从0秒开始执行，每隔1秒执行一次。 当程序运行时，定时任务会按照我们设置的时间间隔执行。这样我们就可以在多线程的环境下实现定时任务的调度了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值