多线程（线程的概述，创建线程，控制线程，线程同步，线程池）

最新推荐文章于 2022-01-10 09:37:09 发布
最新推荐文章于 2022-01-10 09:37:09 发布
阅读量424 收藏 1
点赞数
分类专栏： JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dajiahuooo/article/details/47015513
版权

1.线程的概述

线程是：当一个程序运行时，内部可能包含了多个顺序的执行流，每个执行流就是一个线程。

线程与进程的区别：进程有独立的内存空间地址，线程共享内存空间地址

                  进程是静态的指令集，线程是动态的指令集

                  进程并行性，线程并发性

2.创建线程

方法一：继承Thread类来创建线程类

示例：

/**
 * 继承Thread，重写run()方法
 * 
 * @author Administrator
 * 
 */
public class Demo01 extends Thread {
	public static void main(String[] args) {
		Demo01 d1 = new Demo01();
		d1.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);
		}

	}

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

}


运行结果：


方法二：实现Runnable接口创建线程类

示例：

/**
 * 继承Runnable接口，重写 run()方法
 * @author Administrator
 *
 */
public class Demo02 implements Runnable {

	public static void main(String[] args) {
		Demo02 d = new Demo02();
		new Thread(d).start();//作为参数传给Thread对象
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);

		}

	}

	public void run() {

		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);

		}

	}

}

运行结果：


两者比较：

继承接口Runnable虽然比较麻烦，但是接口可以多继承，还可以继承其他的类，在实际运用中更多。


3.线程的生命周期

线程有新建，就绪，运行阻塞和死亡状态。具体关系如图所示

 

4.控制线程

1）join线程

  让一个线程等待另外一个线程完成。

示例：

public class Demo03 {
	public static void main(String[] args) {
		Thread a = new Thread(new A());
		Thread b = new Thread(new B());
		a.start();
		b.start();
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);
			if(i == 3){
				try {
					//主线程等待a，b线程执行完才执行
					a.join();
					b.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		
	}
		

	}

}

class A implements Runnable{

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

class B implements Runnable{

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

运行结果：


2）后台线程

后台线程是为其他线程服务的，其他线程停止后他也将停止。JVM中的垃圾回收线程是典型

的后台线程。

示例：

public class Demo03 {
	public static void main(String[] args) {
		Thread a = new Thread(new A());
		Thread b = new Thread(new B());
		a.start();
		b.setDaemon(true);//把b线程设为守护线程
		b.start();
	}
		

	}

class A implements Runnable{

	public void run() {
		for (int i = 0; i < 1; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);
		
	}
	}
}

class B implements Runnable{

	public void run() {
		while(true){
			System.out.println("我是B,守护线程！");
		}
	}
		
	}


运行结果：


3）线程休眠：sleep

让正在执行的的线程sleep一下，线程会发生阻塞，线程唤醒时则继续执行。

示例：

public class Demo03 {
	public static void main(String[] args) {
		Thread a = new Thread(new A());
		a.start();
		for (int i = 0; i < 3; i++) {

			System.out.println(Thread.currentThread().getName() + "--" + i);

		}
	}

}

class A implements Runnable {

	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);
			try {
				Thread.sleep(1000);//让线程睡眠1秒
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

运行结果：

 

4)线程让步：yield

让线程等待一下，并不会使线程发生阻塞，而是直接让线程进入就绪状态，让系统重新调度一下，也是完全有可能系统又重新调度了本线程。

示例：

public class Demo03 {
	public static void main(String[] args) {
		Thread a = new Thread(new A());
		a.start();
		for (int i = 0; i < 3; i++) {
			a.yield();//每执行一次主线程，让a线程等待一次
			System.out.println(Thread.currentThread().getName() + "--" + i);

		}
	}

}

class A implements Runnable {

	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);
			
		}
	}
}

运行结果：

 

5）改变线程的优先级

改变线程的优先级，优先级高的线程会得到更多的执行机会，但不绝对。

示例：

public class Demo03 {
	public static void main(String[] args) {
		Thread a = new Thread(new A());
		a.setPriority(10);//把a的优先级设成最高，得到更多的调度机会
		a.start();
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);

		}
	}

}

class A implements Runnable {

	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);
			
		}
	}
}

运行结果：

 


5.线程同步

1）同步代码块

示例：

public class Demo03 {
	public static void main(String[] args) {
		A a = new A();
		Thread t1 = new Thread(a);
		Thread t2 = new Thread(a);
		t1.start();
		t2.start();
		for (int i = 0; i < 3; i++) {
			System.out.println(Thread.currentThread().getName() + "--" + i);

		}
	}

}

class A implements Runnable {
	Object obj = 1;
	int a = 0;

	public void run() {
		synchronized (obj) { // 使用synchronized同步代码块
			for (int i = 0; i < 5; i++) {
				a++;
				System.out.println(Thread.currentThread().getName() + "--" + i
						+ "--" + a);

			}
		}

	}
}

运行结果：

 

2）同步方法

相当于同步代码块中，同步的对象为this，也就是说任意时刻只能有一个线程进入该对象中进行操作。

示例：

public class Demo03 {
	public static void main(String[] args) {
		A a = new A();
		Thread t1 = new Thread(a);
		Thread t2 = new Thread(a);
		t1.start();
		t2.start();
		
	}

}

class A implements Runnable {
	Object obj = 1;
	int a = 0;
	int b = 0;

	public void run() {
		math1();
		math2();
	}
	// 使用synchronized方法
	public synchronized void math1(){
		a++;
		System.out.println(Thread.currentThread().getName() +"我是a++" + a);
	}
	// 使用synchronized方法
	public synchronized void math2(){
		b--;
		System.out.println(Thread.currentThread().getName() +"我是b--" + b);
	}
}

运行结果：

 

3）同步锁

示例：

public class Demo03 {
	public static void main(String[] args) {
		A a = new A();
		Thread t1 = new Thread(a);
		Thread t2 = new Thread(a);
		t1.start();
		t2.start();
		
	}

}

class A implements Runnable {
	Object obj = 1;
	int a = 0;
	int b = 0;
	
	//定义锁对象
	private final ReentrantLock lock = new ReentrantLock();

	public void run() {
		math1();
	}
	
	public  void math1(){
		lock.lock();//加锁
		for (int i = 0; i <5; i++) {
			a++;
			System.out.println(Thread.currentThread().getName() +"我是a++" + a + "--" + i);
		} 
		
		lock.unlock();//释放锁
	}
	
}

运行结果：

 

4）死锁

当两个线程互相等待对方释放同步监视器的时候很容易发生死锁。

示例：

public class Demo05 implements Runnable {
	C c = new C();
	B b = new B();
	
	public void init(){
		c.cMathb(b);
	}
	public static void main(String[] args) {
		//主线程放在第一通常不会死锁，因为主线程的优先级比较高
		Demo05 d = new Demo05();
		new Thread(d).start();
		for(int i = 0; i < 100; i++){
			d.init();
		}
		
		

	}

	public void run() {
		for(int i = 0; i < 100; i++){
			b.bMathc(c);
		}
	}

}

class C {
	public synchronized void cMathb(B b) {
		b.math();
        System.out.println(Thread.currentThread().getName() + "--"+ "c中的cMathb()方法");
	}

	public synchronized void math() {
         System.out.println("c中的math方法");
	}

}

class B {
	public synchronized void bMathc(C c) {
		c.math();
		System.out.println(Thread.currentThread().getName() + " --"+ "c中的cMathb()方法");

	}

	public synchronized void math() {
		 System.out.println("b中的math()方法");
	}
}

运行结果：

 


6.线程池

Java5新增了Executor工厂类来实现生产线程池，开发者不需要手动实现自己的线程池。

示例：

public class Demo06 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		ExecutorService pool = Executors.newFixedThreadPool(3);
		Runnable r =new Runnable() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println(Thread.currentThread().getName() + "--" + i);
				}
			}
		};
		
		pool.submit(r);
		pool.submit(r);
		pool.submit(r);
		//关闭线程池
		pool.shutdown();
	}

}

运行结果：


dajiahuooo
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程的创建和同步
qimojun的博客
05-31 336
线程的创建 Java 虚拟机的主线程入口是 main 方法，用户可以自己创建线程，创建方式有两种： 继承 Thread 类 实现 Runnable 接口（推荐使用 Runnable 接口） 继承 Thread 类 Thread 类中创建线程最重要的两个方法为： public void run() public void start() 采用 Thread 类创建线程，用户只需要继承 Thread，覆盖 Thread 中的 run 方法，父类 Thread 中 的 run 方法没有抛出异常，那么子类也不能抛出
线程、同步、线程池
weixin_44518089的博客
08-06 369
一、线程 创建线程的方式一： 1.继承Thread类 包名：java.lang.Thread 构造方法： Thread()创建新线程 Thread(String name)指定名字的新线程 Thread(Runnable target) 有指定目标的线程 Thread(RUnnable target,String name)创建一个带有目标的线程并指定名字 常用方法： getName：获取线程名称 start:启动线程，调用线程中的run 方法 run：线程要执行任务的代码 sleep:线程要多久才执行，暂
线程的控制与同步
CONSOLE11的博客
09-28 322
一、线程的生命周期 新建、就绪、运行、阻塞、死亡5种状态 使用new创建线程时处于新建状态（JVM为其分配内存，初始化变量），start时线程处于就绪状态（JVM为其创建方法调用栈和程序计数器）。 启动线程的方法是调用start()方法，而不是run(）方法，若调用run()方法，则会把run()方法当其一般方法执行。并且在调用了run方法后，线程不在处于新建状态， 再去调用start（）
多线程的创建、同步
ht_vIC的博客
01-28 201
多线程的创建和同步线程的六种状态新建(NEW)可运行(RUNNABLE)终止(TERMINATED)等待(WATING)计时等待(TIMED_WATING)阻塞(BLOCKED)线程的生命周期线程的创建继承Thread类实现Runnable接口实现Callable接口使用线程池创建线程线程的同步同步代码块继承Thread类的写法实现Runnable接口的写法同步方法继承Thread方法实现Runnable接口 线程的六种状态 新建(NEW) 至今尚未启动的线程处于这种状态。 可运行(RUNNABLE) 一旦
线程的同步 线程池
NuanShuTT的博客
09-16 1418
什么是线程的同步？ 多个线程操作同一个资源的时候回出现资源争夺问题，这就需要线程的同步。 线程的同步要对同一个对象进行，不同对象无法进行线程同步。 线程同步其实就是一种等待机制, 多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕，下一个线程再使用。 实现线程同步的三种方式 synchronized实现线程同步 同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问是的正确性，在访问时加入了锁机制synchronized，当一个
Java多线程之基础篇(一).docx
04-16
Java多线程的使用涉及线程安全、线程通信、线程池等多个方面，需要深入理解并熟练掌握，才能在实际开发中有效地利用多线程优化程序性能。通过合理地设计和使用线程，开发者可以构建出高效、健壮的并发应用程序。
Java 多线程学习总结归纳（附代码）
01-09
1. **多线程概述**： 多线程是指一个程序内可以同时执行多个独立的执行流，每个执行流被称为一个线程。Java通过Thread类来代表线程，每个线程都有自己的生命周期，包括新建、就绪、运行、阻塞和死亡等状态。 2. **...
零基础Java入门课程-多线程
07-01
7. **线程池**：ExecutorService和ThreadPoolExecutor是Java并发编程的重要组成部分，它们允许我们有效地管理和控制线程，避免过度创建和销毁线程带来的开销。 8. **死锁**与**线程通信**：理解死锁的概念以及如何...
java面试题汇总(包括基础，编程，线程，EJB等)
11-22
- **线程同步**：了解synchronized关键字、wait/notify机制、Lock接口及其子类，防止数据不一致。 - **线程状态**：理解新建、就绪、运行、阻塞和死亡等五种线程状态。 - **线程池**：ExecutorService和...
java核心知识，集合，多线程
最新发布
12-11
以上就是Java核心知识中的集合框架和多线程的概述，这些知识点是每个Java开发者必须掌握的基础，对于编写高效、可维护的代码至关重要。在实际项目中，理解和熟练运用这些概念能够帮助我们构建更加健壮的系统。
线程同步&线程池
Gypsophila00的博客
06-02 779
线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象就是其中一种。 在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问...
利用线程池，同步线程实现并发
weixin_30500663的博客
11-29 161
一、CountDownLatch 同步工具类，允许一个或多个线程等待，直到其他的线程操作完成后在执行。 如何工作： CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。 使用场景： 1.实现最大的并行性...
（四十三）、线程的同步和线程池
Rair的博客
08-24 1087
线程的同步同步代码块synchronized放在对象前面限制一段代码的执行同步代码块定义语法：synchronized(对象) { 需要同步的代码; } class TicketOffice implements Runnable { private int tickets = 10; public void run() { while (true) {
Java基础系列：线程同步和线程池
谢先生
01-16 345
深入了解多线程的线程同步和线程池
并发编程：线程中Join方法的使用示例分析
菜鸟技术栈的专栏
05-05 471
Join方法的使用，简单来说就是把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行。 比如在线程 B 中调用了线程 A 的 Join()方法，直到线程 A 执行完毕后，才会继续执行线程 B。 代码示例如下所示： package cn.lspj.ch1.base; public class UseJoin { static class A implements Ru...
实现线程同步的几种方式
htflll的博客
01-10 7881
在多线程中线程的执行顺序是依靠哪个线程先获得到CUP的执行权谁就先执行，虽然说可以通过线程的优先权进行设置，但是他只是获取CUP执行权的概率高点，但是也不一定必须先执行。在这种情况下如何保证线程按照一定的顺序进行执行，今天就来一个大总结，分别介绍一下几种方式。 1.通过Object的wait和notify 2.通过Condition的awiat和signal 3.通过一个阻塞队列 4.通过两个阻塞队列 5.通过SynchronousQueue 6.通过线程池的Callback回调 7.通过同步辅助类Coun
任务，线程和同步（四）之ThreadPool（线程池）
小猪快跑
02-24 2866
线程池任务后台基础：线程池。创建线程需要时间。如果有不同的短任务要完成，就可以事先创建许多线程，在应完成这些任务时发出请求，这个线程最好在需要更多的线程时增加，在需要释放资源时减少。 不需要自己创建这样的一个列表，该表由ThreadPool类托管，这个类会在需要时增减池中线程的线程数，直到达到最大线程数。池中的最大线程数是可配置的。在4核cpu中，默认设置为1023个工作线程，和1000个I/O线
java多线程、线程同步与线程池
博客首页
11-26 501
1. 线程的基本概念 1.1 进程 任何的软件存储在磁盘中,运行软件的时候,OS使用IO技术,将磁盘中的软件的文件加载到内存,程序在能运行。 进程的概念 ： 应用程序(typerpa,word,IDEA)运行的时候进入到内存,程序在内存中占用的内存空间(进程). 1.2 线程 线程(Thread) : 在内存和CPU之间,建立一条连接通路,CPU可以到内存中取出数据进行计算,这个连接的通路,就是线程. 一个内存资源 : 一个独立的进程,进程中可以开启多个线程 (多条通路) 并发: 同一个时刻多个线程同时操作
并发编程44题（含答案）
weixin_42034166的博客
11-21 2822
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见...
多线程学习笔记.docx
06-16
包括线程和进程的关系，线程的三种创建方式，继承thread，实现runnable接口，实现callable接口，线程同步，生产者消费者模式

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值