java_线程、同步、线程池

最新推荐文章于 2022-12-06 15:48:32 发布
最新推荐文章于 2022-12-06 15:48:32 发布
阅读量127 收藏
点赞数
分类专栏： 编程语言 # Java基础 文章标签： 多线程 java 编程语言 并发编程 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guixinchn/article/details/107673826
版权

线程

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例

Thread类常用方法

构造方法

  • public Thread（）：分配一个新的线程对象。
  • public Thread（String name）：分配一个指定名字的新的线程对象。
  • public Thread（Runnable target）：分配一个带有指定目标新的线程对象。
  • public Thread（Runnable target，String name）：分配一个带有指定目标新的线程对象并指定名字。

常用方法

  • public string getName（）：获取当前线程名称。
  • public void start（）：导致此线程开始执行；Java虚拟机调用此线程的run方法。
  • public void run（）：此线程要执行的任务在此处定义代码。
  • public static void sleep（long millis）：使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
  • public static Thread currentThread（）：返回对当前正在执行的线程对象的引用。
创建线程方式一

Java中通过继承Thread类来创建并启动多线程的步骤如下：

  1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把
    run()方法称为线程执行体。
  2. 创建Thread子类的实例，即创建了线程对象
  3. 调用线程对象的start()方法来启动该线程

测试类：

public class Demo{
	public static void main(String[] args) {
		// 创建自定义线程对象
		MyThread mt = new MyThread("新线程");
		// 开启新线程
		mt.start();
		// 在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程正在执行" + i);
		}
	}
}

自定义线程类：

public class MyThread extends Thread {
	// 定义指定线程名称的构造方法
	public MyThread(String name) {
		// 调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName() + "正在执行" + i);
		}
	}
}

流程图：

程序启动运行main时候，java虚拟机启动一个进程，主线程main在main（）调用时候被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行。

创建线程方式二

Java中通过实现Runnable接口来创建并启动多线程的步骤如下：

  1. 定义Runnable接口的实现类，并重写该接口的run () 方法，该run () 方法的方法体同样是该线程的线程执行体。
  2. 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
  3. 调用线程对象的start () 方法来启动线程。

测试类：

public class Demo {
	public static void main(String[] args) {
		// 创建自定义类对象线程任务对象
		MyRunnable mr = new MyRunnable();
		// 创建线程对象
		Thread t = new Thread(mr, "新线程");
		t.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程正在执行" + i);
		}
	}
}

自定义线程类：

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName() + "正在执行" + i);
		}
	}
}

通过实现Runnable接口，使得该类有了多线程类的特征。run () 方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

实现Runnable接口比继承Thread类所具有的优势：

  1. 适合多个相同的程序代码的线程去共享同一个资源。
  2. 可以避免java中的单继承的局限性。
  3. 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和数据独立。
  4. 线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类。
匿名内部类方式实现线程的创建
public class Demo {
	public static void main(String[] args) {
		//使用匿名内部类方法；直接创建Thread类的子类对象
		/*
		 * new Thread() { public void run() { for (int i = 0; i < 10; i++) {
		 * System.out.println("新线程正在执行" + i); } } }.start();
		 */
		//使用匿名内部类方式；直接创建Runnable接口实现类对象
		Runnable r = new Runnable() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println("新线程正在执行" + i);
				}
			}
		};
		new Thread(r).start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程正在执行" + i);
		}
	}
}

线程安全

两个或两个以上的线程在访问共享资源时,仍然能得到正确的结果则称之为线程安全

模拟卖50张电影票

public class Ticket implements Runnable {
	private int ticket = 50;
	// 买票操作
	@Override
	public void run() {
		// 每个窗口买票操作,窗口永远开启
		while (true) {
			if (ticket > 0) {
				// 使用sleep方法模拟买票
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				// 获取当前对象的名字
				String name = Thread.currentThread().getName();
				System.out.println(name + "正在卖票:" + ticket--);
			}
		}
	}
}

测试类:

public class Demo {
	public static void main(String[] args) {
		// 创建线程任务对象
		Ticket ticket = new Ticket();
		// 创建三个窗口卖票
		Thread t1 = new Thread(ticket, "窗口一");
		Thread t2 = new Thread(ticket, "窗口二");
		Thread t3 = new Thread(ticket, "窗口三");

		// 同时开始卖票
		t1.start();
		t2.start();
		t3.start();
	}
}

结果出现了这种现象:

这种问题,几个窗口(线程)票数不同步了,称为线程不安全

线程同步

当我们使用多个线程访问统一资源的时候,且多个线程中对资源有写的操作,就容易出现线程安全问题.

要解决上述多线程并发访问多一个资源的安全性问题,java中提供了同步机制(synchronized)来解决,有三种方式完成同步操作:

  1. 同步代码块
  2. 同步方法
  3. 锁机制

同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

synchronized（同步锁）{
	需要同步操作的代码
}

同步锁注意事项
1.锁对象可以是任意类型。
2.多个线程对象要使用同一把锁。

同步代码块实现线程安全

public class Ticket implements Runnable {
	private int ticket = 50;
	Object lock = new Object();

	// 买票操作
	@Override
	public void run() {
		// 每个窗口买票操作,窗口永远开启
		while (true) {
			synchronized (lock) {
				if (ticket > 0) {
					// 使用sleep方法模拟买票
					try {
						Thread.sleep(1);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					// 获取当前对象的名字
					String name = Thread.currentThread().getName();
					System.out.println(name + "正在卖票:" + ticket--);
				}
			}
		}
	}
}

同步方法

同步方法：使用synchronized修饰的方法，就叫做同步方法保证A线程执行该方法的时候，其他线程只能在方法外等着

public synchronized void method（）{
	可能会产生线程安全问题的代码
}

同步方法实现线程安全

public class Ticket implements Runnable {
	private int ticket = 50;
	// 买票操作
	@Override
	public void run() {
		// 每个窗口买票操作,窗口永远开启
		while (true) {
			sellTicket();
		}
	}
	// 锁对象是谁调用这个方法就是谁,this
	public synchronized void sellTicket() {
		if (ticket > 0) {
			// 使用sleep方法模拟买票
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			// 获取当前对象的名字
			String name = Thread.currentThread().getName();
			System.out.println(name + "正在卖票:" + ticket--);
		}
	}
}

Lock锁

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock常用方法

  • public void lock（）：加同步锁。
  • public void unlock（）：释放同步锁。

Lock锁实现线程安全

public class Ticket implements Runnable {
	private int ticket = 50;
	Lock lock = new ReentrantLock();
	// 买票操作
	@Override
	public void run() {
		// 每个窗口买票操作,窗口永远开启
		while (true) {
			lock.lock();
			if (ticket > 0) {
				// 使用sleep方法模拟买票
				try {
					Thread.sleep(1);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				// 获取当前对象的名字
				String name = Thread.currentThread().getName();
				System.out.println(name + "正在卖票:" + ticket--);
			}
			lock.unlock();
		}
	}

}

线程池

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。


线程池能够带来三个好处：

  1. 降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
  2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  3. 提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存

线程池的使用

Java里面线程池的顶级接口是java.util.concurrent.Executors

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行

Runnable实现类代码：

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("我要一个教练");
	try {
		Thread.sleep(2000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	System.out.println("教练来了： " + Thread.currentThread().getName());
	System.out.println("教我游泳,交完后，教练回到了游泳池");
	}
}

线程池测试类：

public class Demo{
	public static void main(String[] args) {
		// 创建线程池对象
		ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
		// 创建Runnable实例对象
		MyRunnable r = new MyRunnable();
		//自己创建线程对象的方式
		// Thread t = new Thread(r);
		// t.start(); ---> 调用MyRunnable中的run()
		// 从线程池中获取线程对象,然后调用MyRunnable中的run()
		service.submit(r);
		// 再获取个线程对象，调用MyRunnable中的run()
		service.submit(r);
		service.submit(r);
		// 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
		// 将使用完的线程又归还到了线程池中
		// 关闭线程池
		//service.shutdown();
	}
}
咕咕星
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA多线程之线程同步
qq_39367410的博客
10-09 3012
线程同步、并发的基本概念以及解决问题的三种方法
java 线程池 同步_java_线程、同步、线程池
weixin_42509815的博客
02-13 529
线程Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例Thread类常用方法构造方法public Thread()：分配一个新的线程对象。public Thread(String name)：分配一个指定名字的新的线程对象。public Thread(Runnable target)：分配一个带有指定目标新的线程对象。public Thr...
Java多线程之线程同步机制（锁，线程池等等）
熊凯瑞的博客
12-06 2202
同一个对象被多个线程同时操作处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，就需要线程同步，线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。但由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，所以在此基础上，增加锁机制。一个线程持有锁会导致其他所有需要此锁的线程挂起。 （1）在多线程竞争下，加锁，释放锁会导致比较多的上下文切换 和
JAVA线程池的几种使用方式以及线程同步详解
yingziisme的博客
10-07 4730
JAVA创建线程的方法 继承Thread类 public class MyThread extends Thread { @Override public void run(){ // do something } } 实现Runnable接口 public class MyRunnable implements Runnable{ @Ove...
关于java的线程池与同步之间的关系
u012291108的博客
05-24 1352
众所周知，我们在使用同步的时候大部分情况下，都是在线程池的使用过程中，但是不是使用线程池一定会用同步方法呢，其实不然。我们根据原理分析就可知道： 我们之所以会使用同步方法，是因为对同一份共享文件进行写操作，造成数据的不正确匹配，在此时才不得不用同步方法。 同理亦然，只有我们在线程池操作的线程中对同一份文件进行写操作才需要同步方法，否则，请不要乱加同步方法，我遇到过别人跟我提这方面的问题，不知道
Java_线程、多线程与线程池
m0_45101736的博客
06-21 108
线程，线程池，多线程
Java=线程池，死锁，线程状态
人生起落，生活苦甜，坚持追求！
03-18 283
线程池 死锁 线程的状态 定时器 一。线程池 使用线程时,我们会临时创建一个线程,然后启动,而线程的创建,以及线程使用完毕之后的销毁,都是需要消耗性能的. 思考: 能不能事先把线程对象创建好,然后需要用到时直接把创建好的线程拿过来使用, 使用完毕,重新归还,等待下次继续使用??? 能! 其实这就是线程池的思想 线程池: 其实就是一个保存多个线...
java_thread_cn.rar_Java 线程池_java thread books_java线程_线程池_线程池调度
09-14
Java线程调度策略包括抢占式调度和合作式调度。在Java中，默认采用的是抢占式调度，即线程的执行优先级由JVM决定，高优先级的线程可能会中断低优先级线程的执行。然而，开发者可以通过设置线程的优先级来影响调度，...
MultiThread_并发_java_线程池_
09-29
本文将深入探讨标题"MultiThread_并发_java_线程池_"所涵盖的知识点，以及如何在实际编程中利用这些概念。 一、Java并发编程基础 1. 线程与进程：线程是程序执行的最小单位，一个进程中可以有多个线程同时运行。...
Java中的线程与线程池.pptx
最新发布
01-20
Java中的线程与线程池是程序设计中的关键概念，特别是在多任务并行处理和优化系统性能时。本文档深入探讨了这两个主题，旨在帮助开发者更好地理解和应用它们。 线程是为了充分利用CPU资源而引入的执行单元。在多...
java多线程，对多线程，线程池进行封装，方便使用
05-16
在多线程环境中，数据共享和同步是非常重要的。Java提供了synchronized关键字、Lock接口（如ReentrantLock）以及各种并发容器（如ConcurrentHashMap）来保证线程安全。 10. **线程池的最佳实践** - 核心线程数应...
Java 线程状态、线程池
01-20
java 线程状态、线程池 1. java 的线程状态 状态 发生条件 NEW 线程刚刚被创建，没有启动，没有调用start方法 RUNNABLE(可运行) 线程已经在JVM中运行，但是是否运行不确定，看当前线程是否由CPU执行权 ...
xianchengchi.zip_Socket 线程池_socket池_线程池_线程池socket
09-24
1. **同步控制**：使用互斥锁或者其他同步机制（如Java的`synchronized`关键字）确保同一时间只有一个线程能对Socket进行写操作。这样可以避免数据交错，但会降低并发性能。 2. **缓冲区**：每个线程先将数据写入...
多线程与线程池技术详解（图书配套）
07-01
多线程与线程池是Java编程中至关重要的概念，特别是在处理高并发场景时，它们的作用尤为突出。本文将深入探讨这两个主题，并结合标签中的"排它锁"、"重入锁"、"共享锁"等概念进行讲解。 首先，线程是操作系统分配...
java_Thread.rar_java 多线程_java多线程
09-21
- ExecutorService和ThreadPoolExecutor：用于创建和管理线程池，提高系统性能并简化线程管理。 - CyclicBarrier和CountDownLatch：协调多个线程之间的同步。 - Semaphore：信号量，用于控制同时访问特定资源的线程...
Java多线程详解（线程同步）
易果啥笔的博客
08-31 2467
嗨喽～小伙伴们我来了， 上一章，我们通过三个例子（点击跳转）来介绍了线程安全问题，说到线程安全就不得不提到线程同步，它是解决线程安全的一种重要方法。本章就来简单的介绍一下何为线程同步。 从上一章的学习我们知道，当多个线程操作一个资源的时候，就有可能由于线程的不确定切换出现数据不一致的安全问题，那显然，我们要解决这个问题，就得想办法使得资源在某个时间戳只能被一个线程访问。基于这样的思想，我们提出了“队列与锁”的策略： 通俗理解，就是将所有线...
JAVA之线程和线程池
小黑的博客
05-22 345
详解线程和线程池
java多线程还是线程池好
04-04
这取决于具体情况。...3.代码复杂度：使用多线程需要更多的代码来管理线程之间的通信和同步。如果你不熟悉多线程编程，使用线程池可能更容易一些。 总之，你需要根据具体情况来选择哪种方式更适合你的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值