17.多线程(1)

最新推荐文章于 2022-05-23 15:47:03 发布
最新推荐文章于 2022-05-23 15:47:03 发布
阅读量193 收藏
点赞数
分类专栏： javase 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu_intellect/article/details/109035637
版权

多线程

1.多线程定义

  • 每一个应用程序开启后都会开启一个进程,一个进程中可以开启多个线程完成不同的功能,比如qq开启一个进程,qq可以同时聊天、听音乐、看qq空间就是开启了多个线程来完成不同的任务。
  • CPU在某一个时间片只能处理一个任务(线程),如果没有实现多线程,你的qq就应该先执行聊天任务,聊天任务结束才可以听音乐、听音乐任务结束后才可以打开qq空间,我们可以开启多线程,让cpu交替去执行这3个任务,由于cpu计算能力很强,让你感觉这3个任务在同时进行,这样的好处是提高了用户的体验度
  • 总结:有1,2,3个任务,cpu要一件完成之后再去做之后的事情,但是通过多线程实现可以让cpu交替去执行1,2,3任务,让用户在视觉上觉得这三件任务,是在同时执行,提高了用户的体验度。

2.多线程的应用

  • 多线程在java中有着举足轻重的作用,大量应用于服务开发和网络编程。小到自己的程序,大到底层系统的原理,都存在多线程的应用。比如吃鸡游戏,同一个界面多个对战,一个电商网站如淘宝上百万人同时访问,也是多线程实现的,比如12306购票网站,双11天猫抢购都应用了多线程。
  • 负载均衡,物理服务器、云服务器:华为、百度、腾讯、阿里
  • 这些网站和应用都是目前最流性的三高代表:1.高可用 2.高性能 3.高并发
  • 通过多线程我们可以实现高并发

3.并行和并发的区别

  1. 并行:指两个或多个事件在同一时刻发生(同时发生)
  2. 并发:指两个或多个事件在同一时间段内发生
  3. 多线程就是在同一个时间段内多个线程并发执行

4.多线程的好处:

  1. 多线程提高了用户的体验度,使程序的响应速度更快。
  2. 占用大量处理时间的任务可以使用多线程来提高cpu的利用率.即占用大量处理的任务可以通过线程的调度方法让其他任务执行
  3. 多线程可以分别设置优先级来优化性能

5.线程的生命周期

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cMJWn2cE-1602504482161)(E:\图片\images\xian.png)]
在这里插入图片描述

  • 线程的生命周期包含5个阶段:包括新建、就绪、运行、阻塞、销毁
  • 新建:在编译期间创建线程对象属于新建状态,如:Thread t1 = new Thread(myRunnable,“线程A”);
  • 就绪状态:当调用t1.start()方法后就属于就绪状态,这时候线程处于等待cpu执行此线程任务,谁先抢到cpu资源谁就开始执行,是随机性的。
  • 运行状态:当就绪状态的线程获得cpu资源执行任务就是运行状态。run方法中用于定义线程的操作任务
  • 阻塞状态:在运行状态的时候,可能因为某些原因导致运行状态的线程变成了阻塞状态,比如sleep()、wait()等方法让该线程处于阻塞状态,这个时候其他的线程CPU的资源可能性变得更大,CPU并不会等待阻塞的线程(任务),会去执行其他的线程(任务),也可以通过其他机制让阻塞状态的线程唤醒,比如调用notify()或者notifyAll()方法让阻塞的线程恢复就绪状态,直到再次等待CPU分配资源进入运行状态。
  • 销毁状态:如果线程正常执行完毕后或者线程被提前强制的终止或出现异常导致结束,就属于销毁状态,线程的资源释放
  • 具体参考下面线程调度

6.实现线程

  • 实现多线程有4种方式:
    1. 继承Thread父类重写run()方法
    2. 实现Runable接口重写run()方法
    3. 实现callable接口
    4. 线程池实现多线程
  • 主线程
    • 当java 程序启动时,一个线程立刻执行,该线程叫做主线程(main Thread).因为它是程序开始就执行的。
    • 主线程的作用
      1. 它是产生其他子线程的线程。
      2. 通常它必须最后完成执行,因为它需要执行各种关闭操作。

  1. 开启主线程

    /** 
 * 	开启主线程
 * 
 *
 */
public class ThreadTest {
	public static void main(String[] args) {
		//返回当前的线程对象,main方法就是主线程
		Thread t = Thread.currentThread();
		System.out.println(t.getName());
		t.setName("myThread");//设置线程名称
		System.out.println(t.getName());
	}
}

  2. 主线程与子线程交替

    • 子线程

      /** 
 * 	extends Thread 重写run()方法来创建子线程
 * @author Administrator
 *
 */
public class MyThread extends Thread{

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

    • 主线程

      /** 
 * 	extends Thread 重写run()方法来创建子线程
 * @author Administrator
 *
 */
public class MyThread extends Thread{

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

    • 结果

      Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-0:5
Thread-0:6
main()主线程执行了:1600398861751
main()主线程执行了:1600398861751
main()主线程执行了:1600398861751
main()主线程执行了:1600398861751
main()主线程执行了:1600398861751
Thread-0:7
main()主线程执行了:1600398861751
main()主线程执行了:1600398861752
main()主线程执行了:1600398861752
main()主线程执行了:1600398861752
main()主线程执行了:1600398861752
Thread-0:8
main()主线程执行了:1600398861752
Thread-0:9
Thread-0:10

  3. 通过继承Thread父类继承多线程

    /** 
 * 	extends Thread 重写run()方法来创建子线程
 * @author Administrator
 *
 */
public class MyThread extends Thread{

	@Override
	public void run() {
		//线程的任务放在run()方法中执行
		for (int i = 0; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
	
}

    测试

    public class Test {
	public static void main(String[] args) {
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		t1.setName("线程A");
		t2.setName("线程B----------");
		t1.start();
		t2.start();
		
		
	}
}

    因为java是单继承,如果需要实现多线程的类已经继承了其他的父类那么就不能够继承Thread父类,所以建议使用实现Runable接口来实现多线程。

  4. 通过实现Runable接口来实现多线程

    /**
 * 	通过实现Runnable接口来实现多线程
 * @author Administrator
 *
 */

public class MyRunable implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for (int i = 0; i <= 1000; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

    测试

    public class Test {
	public static void main(String[] args) {
		MyRunable myRunnable = new MyRunable();
		Thread t1 = new Thread(myRunnable,"线程A");
		Thread t2 = new Thread(myRunnable,"--线程B---");
		
		t1.start();
		t2.start();
	}
}

  5. 利用多线程下载图片资源

    import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;

import org.apache.commons.io.FileUtils;

public class WebDownloader {

	/**
	 * 	下载图片
	 * @param url
	 * @param name
	 */
	public void downloader(String url, String name) {
		try {
			FileUtils.copyURLToFile(new URL(url), new File(name));
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("不合法的url");
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println("下载失败!");
		}
		
	}
}

    测试

    /**
 * 	多任务下载图片
 * @author Administrator
 *
 */
public class TestDownloader extends Thread{
	 private String url;//下载地址
	 private String name;//下载名称
	 
	public TestDownloader(String url, String name) {
		super();
		this.url = url;
		this.name = name;
	}

	@Override
	public void run() {
		//把任务放在run方法实现多线程(多任务)交替执行
		WebDownloader wd = new WebDownloader();
		wd.downloader(url,name);
		System.out.println("下载图片"+name);
	}
	
	public static void main(String[] args) {
		TestDownloader t1 = new TestDownloader("https://image.baidu.com/", "t1.png");
		TestDownloader t2 = new TestDownloader("https://image.baidu.com/", "t2.png");
		TestDownloader t3 = new TestDownloader("https://image.baidu.com/", "t3.png");
		
		t1.start();
		t2.start();
		t3.start();
	}  
}

  6. 通过匿名内部类实现

    public class Test {
	public static void main(String[] args) {
		
		//通过匿名内部类实现多线程
		new Thread() {
			public void run() {
				for (int i = 0; i <=100; i++) {
					System.out.println("aaa");
				}
			}
		}.start(); 
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i <=100; i++) {
					System.out.println("bbb===============");
				}
			}
		}).start();
	}
}

  7. 实现Callable接口实现多线程

    • Callable接口必须返回一个类型的结果

      import java.util.concurrent.Callable;

public class MyThread implements Callable<Boolean>{

	@Override
	public Boolean call() throws Exception {
		for (int i = 0; i <= 10; i++) {
			try {
				System.out.println(Thread.currentThread().getName()+"正在执行"+i);
			} catch (Exception e) {
				e.printStackTrace();
				return false;
			}
		}
		return true;
	}

}

    • 测试

      import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import day02.MyThread;

public class Test {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
//		Thread t1 = new Thread(new MyThread(),"线程A");
//		Thread t2 = new Thread(new MyThread(),"线程B");
		
		MyThread t1 =new MyThread();
		MyThread t2 =new MyThread();
		
		//通过线程池创建两个线程
		ExecutorService ser = Executors.newFixedThreadPool(2);
		//提交执行
		Future<Boolean> result1 = (Future<Boolean>)ser.submit(t1);
		Future<Boolean> result2 = (Future<Boolean>)ser.submit(t2);

		//实现implements Callable<?>和之前的不一样,这个接口的方法执行线程并且返回一个结果值
		boolean	r1 = result1.get();
		boolean	r2 = result2.get();
		System.out.println(r1);
		System.out.println(r2);
		//4.关闭服务
		ser.shutdown();
	}
}

7.线程调度

  • 线程调度指按照特定的机制为多个线程分配CPU的使用权
方法说明
setPriority(int newpriority)设置线程的优先级
static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠
void join()加入,让正在执行的线程停止,让本线程强制性加入
static void yield()礼让,暂停当前正在执行的线程,让其他线程执行
void interupt()中断线程
boolean isActive()测试线程是否处于活动状态

  1. 设置优先级

    public class MyThread implements Runnable{

	@Override
	public void run() {
		for (int i = 0; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+"正在运行"+i);
		}
		
	}
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread(),"线程A");
		Thread t2 = new Thread(new MyThread(),"线程B=====");
		
		//t1.setPriority(10);
		//t2.setPriority(1);
		//设置优先级后,理论上t1比t2先执行
		t1.setPriority(Thread.MAX_PRIORITY);//设置t1优先级最大
		t2.setPriority(Thread.MIN_PRIORITY);//设置t2优先级最小
		
		t1.start();
		t2.start();
		//获取优先级
		int pri = t1.getPriority();
	}
}

  2. 线程休眠 sleep()

    public class ThreadSleepDemo {
	public static void main(String[] args) {
		ThreadSleepDemo t = new ThreadSleepDemo();
		t.sleepTime(5);
	}

	private void sleepTime(int time) {
		for (int j = 1; j < time; j++) {
			System.out.println("主线程执行了"+j+"秒");
			try {
				//让线程休眠1秒
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
	}
}

    线程休眠后就属于阻塞状态,其他线程就会抢占cpu资源。

  3. join() 强制加入

    子线程

    public class MyThread implements Runnable{

	@Override
	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println(Thread.currentThread().getName()+"运行了:"+i);
		}
	}
	
}

    测试

    public class Test {
	public static void main(String[] args) {
		Thread t = new Thread(new MyThread());
		t.start();
		
		for (int i = 0; i <= 10 ;i++) {
			//当主线程执行第5个任务的时候,让子线程t强行加入进行执行
			if(i==5) {
				try {
					//让子线程强制抢占cpu资源,执行完了之后再给主线程main执行
					t.join();
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName()+"运行"+i);
		}
	}
}

  4. 线程礼让yield()

    子线程

    public class MyThread implements Runnable{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName()+"正在运行了:"+i);
			if(i==3) {
				//线程礼让,让其他线程先执行
				Thread.yield();
			}
		}
	}
	
}

    测试

    public class Test {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyThread(),"子线程A");
		Thread t2 = new Thread(new MyThread(),"子线程B==========");
		t1.start();
		t2.start();
	}
}
不畏未来！不念过去
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用Lambda表达式创建新线程案例
09-07
主要介绍了利用Lambda表达式创建新线程案例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
7.多线程篇1
08-03
【多线程篇1】 在iOS开发中，多线程技术是不可或缺的一部分，它使得应用程序可以同时执行多个任务，提高程序的响应速度和用户体验。本文将深入探讨Cocoa中的NSRunLoop、Run Loop管理、线程同步与通信以及线程调度等...
线程-lambda
欧气满满大顺顺的博客
03-28 1995
并发：同一个时间段内，交替执行 并行：同时执行（更快） 一个程序运行后至少有一个进程，一个进程中可以包含多个线程 单线程，就高速切换 8线程，就8个高速切换 分时调度 Java使用的为抢占式调度 main（主）线程 Thread 一.创建并启动多线程 1.定义Thread类的子类，并重写该类的run()方法 2.创建Thread子类的实例 3.调用线程对象的start()方法来启动该线程（开辟新的...
Java 线程池、Lambda表达式
白长生的小窝
04-14 475
#【线程池、Lambda表达式】 主要内容 等待与唤醒案例 线程池 Lambda表达式 目标 能够理解线程通信概念 能够理解等待唤醒机制 能够描述Java中线程池运行原理 能够理解函数式编程相对于面向对象的优点 能够掌握Lambda表达式的标准格式 能够使用Lambda标准格式使用Runnable与Comparator接口 能够掌握Lambda表达式的省略格式与规则 能够使用...
lambd 创建线程_多线程和Lambda表达式
weixin_29100927的博客
02-17 486
7月20日知识点今天的主要内容——线程线程线程的基本概念线程与进程的区别线程的两种创建方式(掌握)注意线程两种创建方式的区别内部类实现线程创建线程的第三种创建方式——实现Callable接口Thread类中的方法使用getName()setName()currentthread()sleepjoinwaityieldsetDaemon线程的同步(掌握)同步代码块同步方法多线程(线程安全问题)(掌握...
Java学习10 Lambda和线程状态
wuaopan的博客
07-29 639
Lamda表达式 任何接口 如果只包含唯一一个抽象方法,那么它就是一个函数式接口 public interface Runnable{ public abstract void run(); } 对于函数式接口 可以通过Lambda表达式来创建该接口的对象 实质属于函数式编程概念 (params) -> expression (params) -> statement (params) -> {statement} 线程状态 五大状态 setPrio
17-多线程1
08-03
Java中的多线程是编程中的重要概念，尤其在并发处理和优化系统性能方面扮演着关键角色。本节将深入探讨多线程的各个方面。 首先，理解线程的基础知识至关重要。程序是一个指令集，而进程是这些指令在执行过程中的一...
深入浅出Java多线程.pdf
04-27
### 深入浅出Java多线程.pdf #### 知识点概览 本PDF文档涉及了Java多线程的全面介绍，分为基础篇、原理篇和JDK工具篇三个部分，旨在帮助读者深入了解Java多线程的概念、原理及实践应用。 #### 基础篇 **1. 进程...
多线程支持库
07-24
1. **线程创建**：创建新的执行线程是多线程编程的基础。库通常提供API来创建新线程，比如Java中的`Thread`类或者C++中的`std::thread`。 2. **线程同步**：线程同步机制用于控制不同线程之间的执行顺序，防止数据...
2020版Java多线程 21 道.pdf
07-11
12. **保证多线程运行安全**：使用synchronized关键字、Lock接口、Atomic类、ThreadLocal等来控制并发访问，以及避免数据竞争。 13. **锁升级的原理**：Java内存模型中，synchronized锁从无锁、偏向锁、轻量级锁到...
线程同步，线程状态，线程通信，线程池
zza791043251的博客
12-11 254
同步方法 同步方法：使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法的外面等待着，排队。 public synchronized void method() { // 可能会产生线程安全问题的代码 } 备注：同步锁是谁？ ​ 对于非static方法，同步锁就是this ​ 对于static方法，我们使用当前方法所在类的字节码对象(类名.class) 同步方法代码示例如下： @Override public voi
Java创建线程（Lambda表达式创建线程）
weixin_55451557的博客
05-23 7217
一、创建线程三种方式 1.1 继承Thread类创建线程类（main线程与t线程交替执行） 1.2 通过Runnable接口创建线程类 弊端是:不能直接使用Thread中的方法需要先获取到线程对象后,才能得到Thread的方法,代码复杂 上述代码中Thread.currentThread()方法返回当前正在执行的线程对象。GetName()方法返回调用该方法的线程的名字。 public class RunnableThreadTest implements Runnable {...
Lambda方式创建多线程
weixin_55782195的博客
05-24 6337
Lambda方式创建多线程 一、Lambda表达式的标准格式 Lamdba创建线程，是对匿名内部类创建多线程的简化 由三部分组成： a、一些参数 b、一个箭头 c、一段代码 格式： （参数列表）->{一些重写方法的代码} 解释说明： （）：接口中抽象方法的参数列表，没有参数就为空，有参数就写出参数，多个参数用逗号隔开 ->:传递的意思，把参数传给方法体 {}:重写接口的抽象方法的方法体 二、Lambda表达式可省略、可推导 可省略的内
多线程和Lambda表达式
zhang_65044的博客
03-23 1537
今天的主要内容——线程 线程 线程的基本概念 线程与进程的区别 线程的两种创建方式（掌握） 注意线程两种创建方式的区别 内部类实现线程创建 线程的第三种创建方式——实现Callable接口 Thread类中的方法使用 getName() setName() currentthread() sleep join wait yield setDaemon 线程的同步（掌握） 同步代码块 同步方法 多线...
java多线程——简化线程使用以及lambda快速入门
学习学习学习
10-25 3649
简化线程的使用 1、静态内部类 class MyThread{ static class test implements Runnable{ public void run(){ for(int i=0;i<10;i++){ System.out.println("学习_(:з」∠)_"); ...
线程池、lambda表达式
zzz323666的博客
08-20 2277
01.第一章：线程-等待唤醒机制_线程间通信： 1).“线程间通信”：两个线程是在两个相互隔离的“线程栈”中独立运行；但有些业务需要两个线程来协作完成，这样就需要两个线程有相互协作、配合的能力。 2).两个线程进行协作，就需要相互通信，才能共同完成一个任务。 02.第一章：线程-等待唤醒机制_等待与唤醒机制： 1).“等待与唤醒”就是两个线程进行相互协作的一个体现； 2).例如两个线程工作...
第40天学习打卡（静态代理 Lambda表达式 线程状态 线程同步 同步方法）
doudoutj的博客
02-17 250
静态代理 package com.kuang.demo03; //静态代理模式总结 //真实对象和代理对象都要实现同一个接口 //代理对象要代理真实角色 //好处： //代理对象可以做很多真实对象做不了的事情 //真实对象专注做自己的事情 public class StacticProxy { public static void main(String[] args) { You you = new You();//你要结婚 new Thread(()->
线程池、Lambda表达式
09-09 745
day07【线程池、Lambda表达式】 主要内容 等待与唤醒案例 线程池 Lambda表达式 教学目标 -[ ] 能够理解线程通信概念-[ ] 能够理解等待唤醒机制-[ ] 能够描述Java中线程池运行原理-[ ] 能够理解函数式编程相对于面向对象的优点-[ ] 能够掌握Lambda表达式的标准格式-[ ] 能够使用L...
lambda及多线程
forfcw
04-04 1604
1.lambda表达式delegate int caculate(int x, int y); delegate int caculate2();caculate c = new caculate(add); Console.WriteLine(c(1,2));caculate2 c2 = () =&gt; { return 10; } ; Console.WriteLine(c2());2.Fu...
C#多线程开发详解
1. **Introduction and Concepts** - 多线程的概念被介绍，它涉及到同时执行多个任务的能力，这对于提高程序性能和响应性至关重要。 2. **Join and Sleep** - `Join` 方法用于等待一个线程完成其执行，而 `Sleep` ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值