Java基础篇--线程

最新推荐文章于 2023-07-28 20:23:43 发布
最新推荐文章于 2023-07-28 20:23:43 发布
阅读量166 收藏 1
点赞数 1
分类专栏： java 文章标签： java 开发语言 数据结构 线性回归 intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61500949/article/details/124944732
版权

一、线程的概念：

1.线程：是进程中的单个顺序控制流，是一条执行路径

二、线程分类：

1.单线程：一个进程如果只有一条执行路径，则称为单线程程序

2.多线程：一个进程如果有多条执行路径，则称为多线程程序

三、多线程的实现方式：

 1.继承Thread类：

        定义一个类继承Thread类并重写run()方法

2.实现Runnable接口：

        定义一个类实现Runnable接口并重写run()方法

public class Sum extends Thread{
    public void run(){
}
}
public class Sum implements Runnable{
    public void run(){
}
}

四、Thread类设置和获取线程名称的方法：

1.void SetName(String name)：将此线程的名称更改为等于参数name

public class Sum extends Thread{
    public void run(){
}
}
public class Sum {

	public static void main(String[] args) {
        Sum s = new Sum();
        s.setName("火车");
    }
}

2.String getName()：返回此线程的名称

​public class Sum extends Thread{
    public void run(){
}
}
public class Sum {

	public static void main(String[] args) {
        Sum s = new Sum();
        s.setName();
    }
}

3.通过构造方法也可以设置线程名称

​public class Sum extends Thread{
    public Sum(){}
    public Sum(String name){
        super(name);
    }
    public void run(){
}
@Override
	public void run() {
		for(int i = 0;i < 100;i++) {
			System.out.println(getName() + ":" + i);
		}
	}
}
public class Sum {

	public static void main(String[] args) {
        Sum s = new Sum("火车");
    }
}

五、获取main()方法所在的线程名称：

1.public static Thread currentThread():返回当前正在执行的线程对象的引用

​public class Sum {

	public static void main(String[] args) {
       System.out.println(Thread.currentThread().getName());
    }
}

六、线程调用：

1.线程有两种调度模型：

        ①分时调度模型：所有线程轮流使用CPU的使用群，平均分配每个线程占用CPU的时间片

        ②抢占式调度模型：优先让优先级搞的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取CPU时间片想对多一些java使用的是抢占式调度模型 

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

3.run()：封装线程执行的代码，直接调用，相当于普通方法的调用

4.start()：启动线程；然后有java调用此线程的run()方法

5.void start():启动线程

​public class Sum extends Thread{
    public void run(){
}
}
public class Sum {

	public static void main(String[] args) {
        Sum s = new Sum();
        s.setName("火车");
        s.start();
    }
}

七、Thread类中设置和获取线程优先级的方法 ：

1.public final int getPriority():返回此线程的优先级

线程默认优先级是5；线程优先级的范围是：1-10

线程优先级搞仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时间才能看到你想要的效果

​public class Sum extends Thread{
    public Sum(){}
    public Sum(String name){
        super(name);
    }
    public void run(){
}
@Override
	public void run() {
		for(int i = 0;i < 100;i++) {
			System.out.println(getName() + ":" + i);
		}
	}
}
public class Sum {

	public static void main(String[] args) {
        Sum s = new Sum("火车");
        Sum s1 = new Sum("飞机");
        Sum s2 = new Sum("高铁");
        System.out.println(s.getPriority());//5
		System.out.println(s1.getPriority());//5
		System.out.println(s2.getPriority());//5
    }
}

2.public final void setPriority(int newPriority):更改此线程的优先级

线程默认优先级是5；线程优先级的范围是：1-10

线程优先级搞仅仅表示线程获取的CPU时间片的几率高，但是要在次数比较多，或者多次运行的时间才能看到你想要的效果

​​public class Sum extends Thread{
    public Sum(){}
    public Sum(String name){
        super(name);
    }
    public void run(){
}
@Override
	public void run() {
		for(int i = 0;i < 100;i++) {
			System.out.println(getName() + ":" + i);
		}
	}
}
public class Sum {

	public static void main(String[] args) {
        Sum s = new Sum("火车");
        Sum s1 = new Sum("飞机");
        Sum s2 = new Sum("高铁");
        s.setPriority(1);
		s1.setPriority(10);
		s2.setPriority(5);
    }
}

八、线程控制方法：

1.static void sleep(long millis)：使当前正在执行的线程停留(暂停执行)指定的毫秒数

public class Sum extends Thread{
	@Override
	public void run() {
		for(int i = 0;i < 100;i++) {
			System.out.println(getName() + ":" + i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 2.void join():等待这个线程死亡

public class Sum extends Thread{
	@Override
	public void run() {
		for(int i =0;i < 100;i++) {
			System.out.println(getName() + ":" + i);
		}
	}
}
public class Sum1{
    public static void main(String[] args){
        Sum s = new Sum();
        s.join();
    }
}

3.void setDaemon(boolean on):将此线程标记为守护线程，当运行的线程都是守护线程时，java虚拟机将退出

public class Sum extends Thread{
	@Override
	public void run() {
		for(int i =0;i < 100;i++) {
			System.out.println(getName() + ":" + i);
		}
	}
}
public class Sum1{
    public static void main(String[] args){
        Sum s = new Sum();
        s.setDaemon(true);
    }
}

九、线程生命的周期:

1.最开始创建线程对象(新建)，通过使用start()方法线程有了执行资格但是没有执行权(就绪)，当线程强到CPU的执行权时就有执行资格和执行权(运行)，然后使用run()方法或stop()方法结束，线程就会死亡变成垃圾线程(死亡)。

2.当运行时被其他CPU抢走了CPU的执行权就又会回到就绪中，如果运行时被sleep()或其他方法阻塞了就会没有执行资格，没有执行权(阻塞)，但是sleep()方法时间到或者阻塞方式结束就又会回到就绪，然后强CPU

十、实现Runnable接口方法： 

1.定义一个类实现Runnable接口,并重写run()方法

public class Sum implements Runnable(){
    public void run(){
}
}

十一、同步代码块： 

一、锁多条语句操作共享数据，可以使用同步代码块实现
1.格式：
        synchronized(任意对象){
                多条语句操作共享数据的代码
        }

synchronize(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

public class Sum implements Runnable{
    private static int tickets = 100;
	private Object obj = new Object();
	private int x = 0;
@Override
	public void run() {
        while(true) {
		    if(x % 2 == 0) {
                synchronized(HeiMa3_1.class) {
					if(tickets > 0) {
						try {
							Thread.sleep(100);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName() + "正在销售第" + tickets + "张票");
						tickets--;
					}
					}
			}else {
                sellTicket();
        }
					x++;
				}
	}

十二、同步的好处和弊端:

1.好处：解决了多线程的数据安全问题


2.弊端：当线程很多时，因为每一个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

十三、同步方法： 

格式：
        修饰符 synchronized 返回值类型 方法名(方法参数){ }

public synchronized void Sum(){}

 十四、同步静态方法：

格式：
        修饰符 static synchronize 返回值类型 方法名(方法参数){ }

public static synchronize void Sum(){}

十五、线程安全的类：

1.StringBuffer

        ①线程安全，可变的字符序列
        ②从版本JDK5开始，被StringBuilder替代。通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

2.Vector
        ①从java2平台V1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。与新的集合实现不同，Vector被同步。如果不需要线程安全的实现，建议使用ArrayList代替Vector

3.Hashtable
         ①该类实现了一个哈希表，它将键映射到值。任何非null对象都可以用作键或者值
        ②从java2平台V1.2开始，该类进行了改进，实现了Map接口，使其成为java Collections Framework的成员。与新的集合实现不同，Hashtable被同步。如果不需要线程安全的实现，建议使用HashMap代替Hashtable

 十六、Lock锁：

1.虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上的锁，在哪里释放的锁，为了更清晰的表达，如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

2.Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

3.Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化


4.ReentrantLock的构造方法


5.ReentrantLock():创建一个ReentrantLock的实例

3.Lock中提供了获取锁和释放锁的方法：

①void lock():获得锁

 ②void unlock():释放锁

public class Sum implements Runnable{
	private int tickets = 100;
	private Lock lock = new ReentrantLock();
	@Override
	public void run() {
		while(true) {
			try {
			lock.lock();
			if(tickets > 0) {
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName() + "正在销售第" + tickets + "张票");
				tickets--;
			}
		}finally {
			lock.unlock();
		}
		}
	}
}

 十七、Object类的等待和唤醒方法:

1.void wait():导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法

2.void notify():唤醒正在等待对象监视器的单个线程

3.void notifyAll():唤醒正在等待对象监视器的所有线程

4.生产者消费者案例中包含的类：
        ①奶箱类(Sum6_Box):定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
        ②生产者类(Sum6_Producer):实现Runnable接口，重写run()方法，调用存储牛奶的操作
        ③消费者类(Sum6_Customer):实现Runnable接口，重写run()方法，调用获取牛奶的操作
        ④测试类(Sum6):里面有main方法，main方法的代码步骤如下
                1.创建奶箱对象，这是共享数据区域
                2.创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
                3.创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
                4.创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
                5.启动线程

 

public class Sum6_Box {
		//定义一个成员变量，表示第X瓶奶
		private int milk;
		//定义一个成员变量，表示奶箱的状态
		private boolean state = false;
		//提供存储牛奶和获取牛奶的操作
		public synchronized void put(int milk) {
//			如果有牛奶，等待消费
			if(state) {
				try {
//			void wait()								导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
//			如果没有牛奶，就生产牛奶
			this.milk = milk;
			System.out.println("送奶工将第" + this.milk + "瓶奶放入奶箱");
//			生产完毕牛奶，修改奶箱状态
			state = true;
//			唤醒其他等待的线程
			notifyAll();
		}
		public synchronized void get() {
//			如果没有牛奶，就等待牛奶
			if(!state) {
				try {
					wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
//			如果有牛奶，就消费牛奶
			System.out.println("用户拿到第" + this.milk + "瓶奶");
//			消费完毕牛奶，修改奶箱的状态
			state = false;
//			唤醒其他等待的线程
			notifyAll();
		}
}

public class Sum6_Customer implements Runnable{
		private HeiMa6_Box b;
		public HeiMa6_Customer(HeiMa6_Box b) {
			this.b = b;
		}
		@Override
		public void run() {
			while(true) {
				b.get();
			}
		}
}

public class Sum6_Producer implements Runnable{
		private HeiMa6_Box b;
		public HeiMa6_Producer(HeiMa6_Box b) {
			this.b = b;
		}
		@Override
		public void run() {
			for(int i = 1;i <= 5;i++) {
				b.put(i);
			}
		}
}

public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建奶箱对象，这是共享数据区域
		Sum6_Box s1 = new HeiMa6_Box();
		//创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
		HeiMa6_Customer s1 = new HeiMa6_Customer(s);
		//创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
		HeiMa6_Producer s2 = new HeiMa6_Producer(s);
		//创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
		Thread tc = new Thread(s1);
		Thread tp = new Thread(s2);
		//启动线程
		tc.start();
		tp.start();
	}

}

哈喽姥爷
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java线程基础教程完整版
03-14
Java线程基础教程完整版
java基础学习总结——线程(一)
qq_29663071的博客
01-18 297
一、线程的基本概念 　　 线程理解：线程是一个程序里面不同的执行路径 　　每一个分支都叫做一个线程，main()叫做主分支，也叫主线程。 　　程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始
Java基础—线程
xiaosao_的博客
06-19 168
Java基础中的线程
java基础之线程
清风自来
01-08 122
一、线程的优先级 一个进程可以并发多个线程，每条线程执行不同的功能。一个线程不能独立存在，它必须试进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。 每个java线程都有一个优先级，java线程的优先级是一个整数，其取值范围是1（Thread.MIN_PRIORITY）-（Thread.MAX_PRIORITY）。线程的默认优先级为NORM_PRIORITY(5)。 具有高...
JAVA程序员必读--基础篇chm
10-08
Java基础篇的学习通常涵盖以下几个关键知识点： 1. **Java概述**：Java是由Sun Microsystems（现已被Oracle收购）开发的面向对象的编程语言，以其“一次编写，到处运行”的跨平台特性闻名。它基于C++语言，但设计上...
Java面试笔记-基础问题篇.docx
最新发布
08-10
在Java面试中，面试官通常会考察求职者的基础知识，包括语言特性、类库使用、并发处理以及设计模式等。以下是一些Java面试中常见的基础问题及其详细解释： 1. **Java为何高效**：Java的高效主要体现在JVM（Java...
JAVA学习资料-高级篇
07-26
总的来说，这份"JAVA学习资料-高级篇"涵盖了Java多线程、集合框架、反射、I/O流、异常处理、泛型以及模块化等多个核心主题。通过深入学习这些内容，有经验的JAVA开发人员能够进一步提升自己的专业水平，更好地应对...
Java技术教程--基础篇
05-04
本教程“Java技术教程--基础篇”旨在为初学者提供一个全面的Java学习平台，帮助他们掌握Java编程的基础概念和技能。教程内容涵盖Java的核心特性，包括图形用户界面（GUI）、线程管理和网络通信。 首先，我们来深入...
java基础--笔记
01-26
在这篇笔记中，我们聚焦于Java的基础概念，包括this的用法、构造函数的理解以及数组的声明、创建和初始化。 首先，"this"关键字在Java中代表当前对象的引用。它可以用来： 1. 调用本类中的其他构造方法，且需置于...
Java基础之线程篇
未见山的博客
03-13 287
什么是线程？ 线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。 线程的状态： 新建(NEW)：新创建了一个线程对象。 可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。 运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。 阻塞(BLOCKED)：阻塞
Java线程基础
weixin_40536930的博客
09-06 604
Java中线程的声明周期： Java线程中的状态 初始状态（New） 当线程对象创建后，则进入开启一个线程状态（Thread t = new MyThread();） 就绪状态（Runnable） 当调用线程对象的start()方法（t.start()），线程进入了就绪状态。处于就绪状态的线程，知识说明此线程已经做好了准备，随时等待CPU调度执行，并不是说明调用了start方法茨县丞...
Java 基础之多线程
QDJdeveloper
03-09 842
一、什么是线程？它与进程有什么区别？为什么要使用多线程？      线程是指程序在执行过程中，能够执行程序代码的一个执行单元。在 Java 语言中线程有 4 种运行状态：运行、就绪、挂起和结束。       进程是指一段正在执行的程序。而线程有时也被称为轻量级的进程，各个线程之间共享程序的内存空间（代码段、数据段和堆空间）及一些进程级的资源（例如打开文件），但是各个线程拥有自己的栈空间      ...
JAVA基础之多线程
Hackpatrick的博客
11-26 263
今天我们来学学多线程； 首先我们要想清楚多线程的本质，为什么我们要引入多线程呢？ 我们知道进程是我们平时运行的一个程序，它是拥有资源的基本单位；而线程是cpu调度资源的基本单位，它是用来完成任务的；如果没有多线程，一个进程只有一个线程来执行任务，那该进程一次只能做一件事情，无法并发和并行，例如我们所用的Word，如果它有自动保存的功能，那么岂不是说当自动保存的功能在运行时，我们就无法继续输入文字了...
JAVA基础-多线程入门（详解）
0
07-28 958
线程（Thread)是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每个线程并行执行不同的任务。线程在Unix SystemV及SunOS中也被称为轻量进程（Lightweight Processes),但“轻量进程”更多指内核线程（Kernel Thread),而用户线程（User Thread)则被称为“线程”。
Java多线程详细基础教程 全套
qw1666524914的博客
07-14 339
第五章 多线程 理解多线程的基本概念 掌握多线程的创建和使用 掌握多线程的数据共享与同步（线程安全） 了解多线程的死锁问题 了解线程之间的协作 了解线程池的概念和应用 一、多线程的基本概念 1. 线程、进程、程序之间的区别 定义 进程：运行中的程序，操作系统会分配进程给该程序 程序：静态的代码 线程：不能独立存在，线程是存在在进程中，一个进程可以有多个线程 区别 进程：是由cpu创建并分配独立的存储空间，每一个进程都有独立的存储空间 多线程：有独立的运行堆栈和
2020-08-06
weixin_43492559的博客
11-18 126
文章目录 一 进程和多线程简介 1.1 进程和线程 1.2 何为进程？ 1.3 何为线程？ 1.4 何为多线程？ 1.5 为什么多线程是必要的？ 1.6 为什么提倡多线程而不是多进程？ 二 几个重要的概念 2.1 同步和异步 2.2 并发(Concurrency)和并行(Parallelism) 2.3 高并发 2.4 临界区 2.5 阻塞和非阻塞 三 使用多线程常见的三种方式 ①继承Thread类 ②实现Runnable接口 ③使用线程池 四 实例变量和线程安全 4.1 不共享数据的情况 4.2 共享数据
Java 线程基础
m0_50414588的博客
04-02 237
一、线程简介 什么是进程 简言之，进程可视为一个正在运行的程序。它是系统运行程序的基本单位，因此进程是动态的。进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动。进程是操作系统进行资源分配的基本单位。 什么是线程 线程是操作系统进行调度的基本单位。线程也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。 进程和线程的区别 一个程序至少有一个进程，一个进程至少有一个线程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值