Java基础——多线程

最新推荐文章于 2023-04-12 23:49:46 发布
最新推荐文章于 2023-04-12 23:49:46 发布
阅读量596 收藏
点赞数
分类专栏： Java基础 文章标签： java 编程 黑马程序员 计算机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012453500/article/details/41548871
版权

多线程

进程：正在运行的程序，一个进程中至少有一个线程

线程：线程就是进程中的一个控制单元，线程控制着进程的执行

多线程：每个线程在“同时”运行，是因为cpu在做着快读的切换，以达到同时运行的效果

体现：程序主线程在执行，垃圾回收也在执行，这是多线程的体现

1.Thread（继承类）

字段摘要
static intMAX_PRIORITY 
          线程可以具有的最高优先级。10
static intMIN_PRIORITY 
          线程可以具有的最低优先级。5
static intNORM_PRIORITY 
          分配给线程的默认优先级。1
 
构造方法摘要
Thread() 
          分配新的 Thread 对象。
Thread(Runnable target) 
          分配新的 Thread 对象。
Thread(Runnable target, String name) 
          分配新的 Thread 对象。
Thread(String name) 
          分配新的 Thread 对象。
 
方法摘要
static ThreadcurrentThread() 
          返回对当前正在执行的线程对象的引用。
 longgetId() 
          返回该线程的标识符。
 StringgetName() 
          返回该线程的名称。
 intgetPriority() 
          返回线程的优先级。
 Thread.StategetStat() 
          返回该线程的状态。
 voidsetName(String name) 
          改变线程名称，使之与参数 name 相同。
 voidinterrupt() 
          中断线程。对线程冻结状态进行清除，强制让线程恢复到状态中来，可以操作标记让线程结束
 voidsetDaemon(boolean on) 
          将该线程标记为守护线程或用户线程。当前台线程都结束后，守护线程自动结束（后台线程）
 voidjoin() 
          等待该线程终止。获得主线程执行权，等待该线程终止，主线程才执行。只有main方法叫主线程。 throws InterruptedException
 StringtoString() 
          返回该线程的字符串表示形式，包括线程名称、优先级和线程组。
 voidsetPriority(int newPriority) 
          更改线程的优先级。所有线程优先级默认为5
static voidyield() 
          暂停当前正在执行的线程。临时释放线程的执行权

1.1 要点：

（1）步骤：Thread子类需要重写run()方法，运行run()方法可通过start()方法。此时Java进程下就有两个线程了，主线程和我们创建的线程

（2）run方法：其就是一个存储器，存储线程要运行的代码

（3）start方法：开启新线程并运行。不用start()方法运行run()方法，程序还是单线程

（4）分析：运行结果每一次都不一样，因为多个线程都在争抢cpu执行权，不过每一时刻只能有一个线程在执行（多核除外）

/**
*需求：站台售票实例，通过继承实现多线程
*思路：因为要多个对象共享票的数量，需要对票数进行静态修饰
*/
class ticket extends Thread
{
	private static int tic = 100;//票数
	public ticket(String stageName){//站台名
		super(stageName);
	}

	public void run(){//线程的方法体
		while(true)
			if(tic>0)
				System.out.println(Thread.currentThread().getName()+"....还剩"+tic--+"张票");
		//System.out.println("票已经售完");
	}
}

class java
{
	public static void main(String[] args){
		new ticket("站台1").start();
		new ticket("站台2").start();
		new ticket("站台3").start();
		new ticket("站台4").start();

	}
}

1.2 线程运行的状态

（1）被创建：待运行

（2）运行：拥有运行资格以及执行权

（3）冻结：放弃了运行资格

（4）阻塞：拥有运行资格却没有执行权

（5）消亡：没有运行资格

线程状态图

2.Runnable（实现接口）

方法摘要
 voidrun() 
          使用实现接口 Runnable 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 run 方法。

2.1 步骤

class MyThread implements Runnable
{
	public void run(){
		//多线程要执行的方法体;
		System.out.println(Thread.currentThread().getName());
	}
}

class java
{
	public static void main(String[] args){
		//建立自定义线程类对象
		Runnable r = new MyThread();

		//建立线程类，并通过Thread(Runnable r)来传入自定义线程类对象
		Thread t1 = new Thread(r);
		Thread t2 = new Thread(r);
		
		//运行多线程
		t1.start();
		t2.start();

		//简易写法
		new Thread(r).start();

2.2 特点

（1）好处：Java只支持单继承，如果该类已经是一个体系中子类，那么不能够运用继承来实现该类方法的多线程形式

（2）现状：实现方式最常用

3. 线程的安全

3.1 问题产生原因

（1）重要：当多条语句在操作同一个线程的共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误

3.2 问题的解决（synchronized——同步）

（1）同步代码格式如下

//同步代码块格式
synchronized(对象){//对象为任意对象
	需要被同步的代码块
}

//同步函数格式
synchronized 作为函数的修饰符
（2）同步的含义：同步就是确保同一时间段内只有一个线程能访问这段代码

（3）同步的前提

     <1>.必须要有一个或两个以上的线程

     <2>.必须是多个线程共同使用一把锁、监视器（锁就是对象，每一把锁都有自己的状态值，每进去一个线程此状态值都会变化）

（4）注意：同步较为消耗资源，所以尽可能减少判断的同步的次数，同步尽可能少的代码

（5）同步函数的要点

     <1>.同步函数使用的锁是 this

     <2>.静态同步函数使用的锁是 类名.class（字节码文件对象）

（6）死锁：同步嵌套同步，而且必须互相调用时，可能会发生。代码如下：

//死锁实现

//死锁类，自定义线程类
class DeadLock implements Runnable
{
	private boolean flag;//标记
	DeadLock(boolean flag){
		this.flag = flag;
	}

	public void run(){
		if(flag)
			synchronized(MyLock.locka){//死锁嵌套形式
				System.out.println(Thread.currentThread().getName()+"......locka");
				
				synchronized(MyLock.lockb){
					System.out.println(Thread.currentThread().getName()+"......lockb");
				}
			}
		else
			synchronized(MyLock.lockb){
				System.out.println(Thread.currentThread().getName()+"......lockb");
				
				synchronized(MyLock.locka){
					System.out.println(Thread.currentThread().getName()+"......locka");
				}
			}
	}
}

//提供锁的类
class MyLock
{
	public static Object locka = new Object();
	public static Object lockb = new Object();

}

class java
{
	public static void main(String[] args){
		new Thread(new DeadLock(true)).start();//多线程的简便写法，会创建两个定义一线程类对象
		new Thread(new DeadLock(false)).start();
	}
}

4.线程间通信

4.1 情况阐述：

（1）多个线程中每个线程运行的代码都不同

4.2 等待唤醒机制

（1）方法摘要（Object类）

方法摘要
 voidwait() 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。throws InterruptedException
 voidnotify() 
          唤醒在此对象监视器上等待的单个线程。
 voidnotifyAll() 
          唤醒在此对象监视器上等待的所有线程。
 voidwait(long timeout) 
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。throws InterruptedException
（2）特点

      <1>.操作这些方法的对象是同步中的锁对象，因为可以通过监视器来确定线程。只有在同步中才能使用这些方法

      <2>.等待和唤醒必须是同一把锁，只有同一把锁的等待线程能被同一把锁的notify唤醒

      <3>.因为锁可以是任意对象，所以这些方法定义在Object类中

（3）输入和输出的代码体现（繁琐代码）————wait()、notify()的应用

/**
*需求：等待唤醒机制通过输入输出的形式体现。只适合两个线程，一个输入一个输出
*思路：1.建立资源类，输入类，输出类
*	  2.输入类、输出类是多线程的实现类，并且分别用一个线程来控制其输入输出过程
*	  3.同步解决线程完全问题、等待唤醒机制实现输入一次输出一次的形式
*/
class Res
{
	String name;
	String sex;
	boolean b = false;//等待唤醒的判断依据
}

class Input implements Runnable
{
	//资源类的引用
	Res r;

	//保证传入对象唯一
	Input(Res r){
		this.r = r;
	}

	public void run(){
		int x = 0;//自定义的判断条件
		while(true){
			synchronized(r){
				if(r.b)
					try{r.wait();}catch(Exception e){}//等待机制
				if(x==0){
					r.name="张欣";
					r.sex="女";//输入
				}
				else{
					r.name="Tom";
					r.sex="man";
				}
				x = (x+1)%2;//通过此运算x的值始终为0或1
				r.notify();//唤醒机制
				r.b = true;
			}
		}
	}
}

class Output implements Runnable
{
	//同上
	Res r;
	Output(Res r){
		this.r = r;
	}

	public void run(){
		while(true){
			synchronized(r){
				if(!r.b)
					try{r.wait();}catch(Exception e){}//等待机制
				System.out.println(r.name+"......"+r.sex);//输出
				r.notify();
				r.b = false;
			}
		}
	}
}

class java
{
	public static void main(String[] args){
		Res r = new Res();//建立唯一的资源类对象
		
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();//运行多线程
	}
}
（4）生产者和消费者的代码体现（简化代码）————while多次判断标记、nitifyAll()唤醒全部等待线程 

/**
*需求：用生产者消费者的形式来实现线程通信（有超过两个线程操作程序）
*思路；1.建立资源类、生产者类、消费者类
*	  2.资源类中建立生产消费的函数，来被生产者消费者调用
*	  3.用同步解决线程安全问题，用等待唤醒全部机制保证生产一个消费一个
*/
class Resource
{
	private String name;//商品名称
	private int count;//商品序号
	private boolean flag = false;//判断等待唤醒的标记

	Resource(String name){
		this.name = name;
	}

	//生产函数
	public synchronized void pdt(){
		while(flag)//多次判断标记
			try{wait();}catch(Exception e){} 
		System.out.println(Thread.currentThread().getName()+"...生产者..."+(++count)+"."+name);//生产一个商品，每生产一个序号+1
		flag = true;
		notifyAll();//唤醒全部等待线程
	}

	//销售函数
	public synchronized void sell(){
		while(!flag)
			try{wait();}catch(Exception e){}
		System.out.println(Thread.currentThread().getName()+"...消费者........."+count+"."+name);//销售一个商品
		flag = false;
		notifyAll();
	}
}

class Produce implements Runnable
{
	private Resource res;//资源引用
	Produce(Resource res){//保证资源对象唯一
		this.res = res;
	}

	//多线程run方法，存放生产的过程
	public void run(){
		while(true){
			res.pdt();
		}
	}
}

class Customer implements Runnable
{
	private Resource res;//资源引用
	Customer(Resource res){//保证对象唯一
		this.res = res;
	}

	//多线程run方法，存放销售的过程
	public void run(){
		while(true){
			res.sell();
		}
	}
}

class java
{
	public static void main(String[] args){
		//建立要用的唯一资源对象
		Resource res = new Resource("手办");

		//建立两个生产线程
		new Thread(new Produce(res)).start();
		new Thread(new Produce(res)).start();

		//建立两个销售线程
		new Thread(new Customer(res)).start();
		new Thread(new Customer(res)).start();
	}
}

类 ReentrantLock

5. JDK5.0升级

5.1 知识

（1）JDK5.0升级后多线程的同步与等待唤醒机制被替代，工具包位置为 java.util.concurrent.locks

（2）synchronized关键字的功能被lock接口子类ReentrantLock中的方法替代，wait()、nitify()、notifyAll()被Condition接口子类 中的方法所替代

5.2 类概要

Lock接口（常用子类——ReentrantLock）

方法摘要
 voidlock() 
          获取锁。
 voidunlock() 
          释放锁。
ConditionnewCondition() 
          返回绑定到此 Lock 实例的新 Condition 实例。


Condition接口

方法摘要
 voidawait() 
          造成当前线程在接到信号或被中断之前一直处于等待状态。throws InterruptedException
 voidsignal() 
          唤醒一个等待线程。
 voidsignalAll() 
          唤醒所有等待线程。


5.3 实现代码（实现本方只唤醒对方的操作，上边生产者消费者代码的转型）

/**
*需求：用JDK5.0新特性实现生产者和消费者线程通信
*思路；1.建立资源类、生产者类、消费者类
*	  2.资源类中建立生产消费的函数，来被生产者消费者调用
*	  3.用同步解决线程安全问题，用等待唤醒全部机制保证生产一个消费一个
*/
import java.util.concurrent.locks.*;

class Resource
{
	private String name;//商品名称
	private int count;//商品序号
	private boolean flag = false;//判断等待唤醒的标记
	
	private Lock lock = new ReentrantLock();//同步对象

	private Condition conditionPro = lock.newCondition();//锁对象
	private Condition conditionCus = lock.newCondition();

	Resource(String name){
		this.name = name;
	}

	//生产函数
	public void pdt(){
		lock.lock();//锁住
		try{
			while(flag)//多次判断标记
				conditionPro.await();
			System.out.println(Thread.currentThread().getName()+"...生产者..."+(++count)+"."+name);//生产一个商品，每生产一个序号+1
			flag = true;
			conditionCus.signalAll();//指定唤醒哪些线程
		}catch(Exception e){}
		finally{
			lock.unlock();//释放锁
		}
	}

	//销售函数
	public void sell(){
		lock.lock();
		try{
			while(!flag)
				conditionCus.await();
			System.out.println(Thread.currentThread().getName()+"...消费者........."+count+"."+name);//销售一个商品
			flag = false;
			conditionPro.signalAll();
		}catch(Exception e){}
		finally{
			lock.unlock();//释放锁
		}
	}
}

class Produce implements Runnable
{
	private Resource res;//资源引用
	Produce(Resource res){//保证资源对象唯一
		this.res = res;
	}

	//多线程run方法，存放生产的过程
	public void run(){
		while(true){
			res.pdt();
		}
	}
}

class Customer implements Runnable
{
	private Resource res;//资源引用
	Customer(Resource res){//保证对象唯一
		this.res = res;
	}

	//多线程run方法，存放销售的过程
	public void run(){
		while(true){
			res.sell();
		}
	}
}

class java
{
	public static void main(String[] args){
		//建立要用的唯一资源对象
		Resource res = new Resource("手办");

		//建立两个生产线程
		new Thread(new Produce(res)).start();
		new Thread(new Produce(res)).start();

		//建立两个销售线程
		new Thread(new Customer(res)).start();
		new Thread(new Customer(res)).start();
	}
}

知识点：当多个不操作共享数据的程序运行时，分别定义多线程效率较高，可以使用匿名内部类的方式

桃华月禅
关注
专栏目录
JAVA作业——多线程抢红包
Evrse的博客
03-27 6704
JAVA作业——抢红包大体思路代码实现 大体思路 红包的分发见JAVA作业——红包分发。 而抢红包要解决的是线程问题。 其实比较简单，设定好人数，每个人一个线程，每个线程执行一遍，有红包就抢，没有红包就抢不到，所以run函数中只要判断现在还有没有红包就可以了。 代码实现 import java.util.Random; import java.util.Scanner; public class Main { public static void main(String[] args) {
Java——多线程编程技术.pdf
12-31
"Java多线程编程技术.pdf" Java多线程编程技术是Java平台的一个重要技术优势，是第一个直接把跨平台线程模型和标准的内存模型集成到语言中的主流语言。多线程编程技术是Java平台的一个重要技术优势，它可以使程序的...
java基础——多线程
wbcra的博客
06-14 3005
并发与并行 l并行:指两个或多个事件在同一时刻发生(同时发生)。 l并发:指两个或多个事件在同一个时间段内发生。
超详细JAVA基础——多线程
热门推荐
qq_45781655的博客
04-12 2万+
学会Java多线程，只看一个博客就够了！
java基础——多线程基础
上邪的博客
10-15 417
java基础 笔记的都是需要背诵的零散知识点，以顺序的方式组织 文章目录java基础一、多线程基本使用1、创建线程的两种方式 一、多线程基本使用 1、创建线程的两种方式 （1）继承Thread类,重写run方法 （2）实现 Runnable接口,重写run方法 ...
java基础——多线程(一)
weixin_34199171的博客
07-09 240
java基础——多线程(一) 知行合一
Java基础——多线程——使用Thread创建线程并启动
虚知
05-05 1125
文章目录前言一、线程是什么？二、线程的创建三、线程的创建总结 前言 本文主要介绍了什么是线程，什么是进程，线程的创建方法中Thread方法 一、线程是什么？ 讲述线程之前，我们先来了解一下什么是进程，进程是指可执行程序并存放在计算机存储器中的一个指令序列，是一个动态执行的过程，而线程是比进程还小的执行单位，一个进程可以包含多个线程。 二、线程的创建 基础上我们先了解两种创建方式，一种是创建一个Thread类或者其子类的对象，另外一种是实现runnable接口的类的对象。 首先我们来介绍Thread类，T
Java 基础 —— 线程安全
IT__learning的博客
10-31 9029
一、线程安全问题 线程安全 当多个线程访问一个对象时，如果不用考虑这些线程在运行时环境下的调度和交替执行，也不需要进行额外的同步，或者在调用方进行任何其他的协调操作，调用这个对象的行为都可以获得正确的结果，那这个对象就是线程安全的 一个程序在运行起来的时候会转换成进程，通常含有多个线程。通常情况下，一个进程中的比较耗时的操作（如长循环、文件上传下载、网络资源获取等），往往会采用多线程来解决。又比如实际生活中，银行取钱问题、火车票多个售票窗口的问题，通常会涉及到并发的问题，从而需要多线程的技术。 当进程中
Java多线程——线程同步
u010759175的专栏
12-28 3016
1.不安全的买票 //不安全的买票 //线程不安全，有负数或者多人买到同一张票 public class UnsafeBuyTicket { public static void main(String[] args) { BuyTicket buyTicket = new BuyTicket(); new Thread(buyTicket,"苦逼的我").start(); new Thread(buyTicket,"牛逼的你们").start(); new Thread(buyTic
Java程序设计——多线程
Mr_John
12-01 2326
一、多线程的概念 1.进程 ——在一个操作系统中，每个独立执行的程序都可称之为一个进程，也就是“正在运行的程序”。 ——目前大部分计算机上安装的都是多任务操作系统，即能够同时执行多个应用程序。 ——在计算机中，所有的应用程序都是由CPU执行的，对于一个CPU而言，在某个时间点只能运行一个程序，也就是说只能执行一个进程。 2.线程 ——每个运行的程序都是一个进程，在一个进程中还可以有多个执行单元同时运行，这些执行单元可以看做程序执行的一条条线索，被称为线程。 ——操作系统中的每一个进程中都至
Java练手小项目——多线程聊天室.zip
最新发布
01-14
【Java练手小项目——多线程聊天室】 在Java编程世界中，多线程是不可或缺的一部分，尤其在开发实时性、交互性强的应用时，如我们的主题“多线程聊天室”。这个实战项目旨在帮助开发者深入理解Java多线程的概念，并...
JAVA面试题——多线程.docx
06-12
### JAVA面试题——多线程知识点详解 #### 一、线程与进程的基本概念 线程和进程是并发编程中的两个基本概念。进程是操作系统进行资源分配和调度的基本单位，而线程则是进程中的实际运行单元。每一个进程都有其...
Java基础——I/O流
桃华月禅的专栏
12-08 1462
I/O流 IO流（数据流）：对存储设备上的数据进行操作 硬盘磁头：复制文件时这里复制一次，磁头在这边复制一次；写入的那边，写一次磁头移动到那边又写一次。硬件移动花费时间量大，所以复制时要定义足够大的缓冲区来一次性复制大量数据并写入，大大增加效率 I/O流输入输出设备区分： 源设备：内存System.i
Java基础——反射、枚举
桃华月禅的专栏
12-26 1212
一.反射 1.使用情景 当你做程序开发时，你会发现定义接口，可以提高程序扩展性，扩展功能类实现接口即可。可是你会发现源码中只有引用型变量不用修改了而已，扩展功能时不能避免的就是建立功能类的对象，对象是必须要建立的。这时就有了反射技术出现解决了这一问题，只要你把功能类类名定义在一个指定配置文件中，你不用修改
Java基础——异常（Error、Exception）
桃华月禅的专栏
11-25 1070
异常（Throwable） Java对问题进行了对象的封装，Java对不正常情况进行描述后的对象体现，这就是Throwable类 方法摘要  String getMessage()            返回此 throwable 的详细消息字符串。（异常信息）
Java基础——API文档，说明书的制作
桃华月禅的专栏
11-10 843
一.API文档(Aplication Program Interface) 1.API是Java说明文档，是一个记述了全部Java官方开发类的说明文档 2.制作一个程序的说明文档 2.1 程序的代码部分书写格式如下 /** 这是一个可以对数组进行操作的工具包，该类中提供了————获取最值、排序、打印最
Java基础——网络编程
桃华月禅的专栏
12-22 793
一.网路编程知识 意义：过去我们IO流是把本地的文件传递而已，网络编程是把自己电脑的数据传递给另一台电脑，并且回馈信息。这是数据通讯 1.通讯三要素 1.1 IP地址 （1）获取对方主机IP 1.2 端口号 （1）数据发送到对方主机指定的应用程序上，为了区别主机上的应用程序，会定义一些数字标识（端
Java基础——常用API
桃华月禅的专栏
12-05 789
System类 1.知识点 （1）所在位置：java.lang包 （2）特点：不能够实例化，所以成员全部是静态的 2.成员摘要 字段摘要 static PrintStream err            “标准”错误输出流。 static InputStre
Java多线程编程实战指南
"Java多线程编程深入详解"是一本全面介绍Java多线程的书籍，适合有一定Java基础并希望深入理解并发编程的开发者。通过实例和详尽的解释，读者可以掌握如何在Java中有效地使用多线程，提升程序的并发性能和系统效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值