Java基础学习(八) - 多线程
理解线程
进程是指一个内存中运行的应用程序,系统运行一个程序即是一个进程从创建,运行,结束的过程。
线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。
多线程的特点是并发执行(同一时间段执行多个任务),实际上并不能提高程序运行速度,但能够提高运行效率,让cpu使用率更高。
关于线程调度,分为分时调度和抢占调度。
- 抢占调度模式,需要设置线程的优先级,优先级别高的线程优先使用cpu。
- 分时调度,所有线程轮流使用cpu,平均分配每个线程占用cpu的时间。
1.Java中的多线程实现
Java中实现多线程有两种方式:
- 继承Thread类并重写run方法,创建Thread对象执行。
- 定义Runable接口的实现类,并重写接口的run方法(线程执行体)。Runnable实现类里包含的run()方法仅作为线程执行体,然后传递给Thread对象执行。
实现Runnable接口比继承Thread类所具有的优势:
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性,实现解耦操作,代码可以被多个线程共享,代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程,不能直接放入继承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() :返回对当前正在执行的线程对象的引用。
下面通过代码来了解执行过程:
//继承Thead实现
class MyThead extends Thread{
public MyThead(String name){
super(name);
}
@Override
public void run(){
System.out.println("我是线程"+getName());
}
} public class TestThread {
public static void main(String[] args){
//创建线程对象
MyThead mt = new MyThead("M");
//开启一个新的线程
mt.start();
System.out.println("我是main线程");
}
}
//实现Runnable,重写run方法
class MyRunable implements Runnable{
@Override
public void run(){
System.out.println("我是线程"+ Thread.currentThread().getName());
}
}
public class TestRunable {
public static void main(String[] args){
//创建 MyRunable对象
MyRunable mr = new MyRunable();
//创建线程对象
Thread t = new Thread(mr,"t");
//运行线程
t.start();
System.out.println("我是main线程");
}
}
2.线程同步
使用多个线程访问同一资源的时候,并在线程中修改资源,就会出现线程安全问题。
//实现Runnable,重写run方法
class MyRunable implements Runnable{
private int a = 10;
@Override
public void run(){
while (a > 0){ try{
Thread.sleep(10);
}catch (InterruptedException e){
e.printStackTrace();
}
a -= 1;
System.out.println("线程"+Thread.currentThread().getName()+"操作了a,a的值为"+a);
} }
}
public class TestRunable {
public static void main(String[] args){
//创建 MyRunable对象
MyRunable mr = new MyRunable();
//创建线程对象
Thread t1 = new Thread(mr,"t1");
Thread t2 = new Thread(mr,"t2");
Thread t3 = new Thread(mr,"t3");
//运行线程
t1.start();
t2.start();
t3.start(); }
}
由于多个线程操作变量a,导致a的值异常(-1不应该出现)。
线程安全问题都是由于多线程对全局变量进行修改操作引起的,这时就需要使用线程同步。
线程同步原理:
在一个线程操作资源时,其他线程不允许操作,保证数据的同步性。
Java中提供了三种方式来实现线程同步。
- 同步代码块:synchronized 关键字可以用于方法中的某个区块中,为区块代码添加互斥访问。
同步方法 :使用synchronized修饰方法。一个线程在执行该方法时,其他线程阻塞。
- Lock 锁:也称同步锁,加锁与释放锁方法化了。
同步代码块:
//实现Runnable,重写run方法
class MyRunable implements Runnable{
private int a = 10;
//同步锁
Object lock = new Object();
@Override
public void run(){
while (true){
synchronized (lock){
if (a > 0){
try{
Thread.sleep(50);
}catch (InterruptedException e){
e.printStackTrace();
}
a -= 1;
System.out.println("线程"+Thread.currentThread().getName()+"操作了a,a的值为"+a); } }
}
}
}
public class TestRunable {
public static void main(String[] args){
//创建 MyRunable对象
MyRunable mr = new MyRunable();
//创建线程对象
Thread t1 = new Thread(mr,"t1");
Thread t2 = new Thread(mr,"t2");
Thread t3 = new Thread(mr,"t3");
//运行线程
t1.start();
t2.start();
t3.start(); }
}
同步方法:
//实现Runnable,重写run方法
class MyRunable implements Runnable{
private int a = 10;
@Override
public void run(){
while (true) {
method1();
}
}
//同步方法
public synchronized void method1(){
if (a > 0){
try{
Thread.sleep(50);
}catch (InterruptedException e){
e.printStackTrace();
}
a -= 1;
System.out.println("线程"+Thread.currentThread().getName()+"操作了a,a的值为"+a); }
}
}
public class TestRunable {
public static void main(String[] args){
//创建 MyRunable对象
MyRunable mr = new MyRunable();
//创建线程对象
Thread t1 = new Thread(mr,"t1");
Thread t2 = new Thread(mr,"t2");
Thread t3 = new Thread(mr,"t3");
//运行线程
t1.start();
t2.start();
t3.start(); }
}
Lock锁包含两个方法:
- public void lock() :加同步锁。
- public void unlock() :释放同步锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; //实现Runnable,重写run方法
class MyRunable implements Runnable{
private int a = 10;
//同步锁
Lock lock = new ReentrantLock();
@Override
public void run(){
while (true){
//加锁
lock.lock();
if (a > 0){
try{
Thread.sleep(20);
}catch (InterruptedException e){
e.printStackTrace();
}
a -= 1;
System.out.println("线程"+Thread.currentThread().getName()+"操作了a,a的值为"+a); }
//释放锁
lock.unlock();
}
}
}
public class TestRunable {
public static void main(String[] args){
//创建 MyRunable对象
MyRunable mr = new MyRunable();
//创建线程对象
Thread t1 = new Thread(mr,"t1");
Thread t2 = new Thread(mr,"t2");
Thread t3 = new Thread(mr,"t3");
//运行线程
t1.start();
t2.start();
t3.start(); }
}
3.线程状态
- NEW:线程创建未启动。
- Runnable:可运行。
- Blocked:锁阻塞。当一个线程获得同步锁时,其他线程会被阻塞,直到获得同步锁。
- Waiting:无限等待。当一个线程进入Waiting状态后,会无限等待,直到其他线程调用notify或者notifyAll方法唤醒(线程通信)。
- TimedWaiting:计时等待。当一个线程调用sleep方法时,程序会进入计时等待,直到时间结束。
Teminated:被终止。run方法未正常退出而死亡。
4.线程通信
多个线程在处理同一资源,但是线程任务却不相同,当我们希望有规律的执行吗,那么线程之间需要一些协调通信。
线程通信的核心是等待唤醒机制。等待唤醒机制是多线程间的一种协作机制,就是一个线程执行wait操作进入无限等待状态,等待其他线程执行 notify 唤醒线程,或者使用 notifyAll 来唤醒所有的等待线程 。
等待唤醒方法:
- wait:线程进入wait状态,不会去参与调度。
- notify:释放所通知对象的一个线程。
- nofifyAll:释放所通知对象的全部线程。
唤醒方法使用注意:
- wait 和 notify 方法必须要由同一个所对象调用。
- 两个方法都是属于object类的方法。
- 两个方法必须要在同步代码块或同步函数中。因为必须要通过锁对象调用这两个方法。
案例:生产者与消费者模型。
class BaoZi {
boolean flag = false ;//包子资源 是否存在 包子资源状态
}
class ChiHuo extends Thread{
private BaoZi bz;
public ChiHuo(String name,BaoZi bz){
super(name);
this.bz = bz;
}
@Override
public void run() {
while(true){
//把包子当做同步锁对象
synchronized (bz){
if(bz.flag == false){//没包子
try {
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("吃货正在吃包子");
bz.flag = false;
System.out.println("吃完了");
bz.notify();
}
}
}
}
class BaoZiPu extends Thread {
private BaoZi bz;
public BaoZiPu(String name,BaoZi bz){
super(name);
this.bz = bz;
} @
Override
public void run() {
int count = 0;
while(true){
synchronized (bz){
if(bz.flag == true){//包子资源 存在
try {
bz.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("包子铺开始做包子");
count++;
bz.flag=true;
System.out.println("包子造好了");
System.out.println("吃货来吃吧");
//唤醒线程
bz.notify();
}
}
}
} public class TestRunable {
public static void main(String[] args){
//创建包子对象
BaoZi bz = new BaoZi();
ChiHuo ch = new ChiHuo("吃货",bz);
BaoZiPu bzp = new BaoZiPu("包子铺",bz);
ch.start();
bzp.start();
}
}
5.线程池
线程池可以容纳多个线程,用于解决频繁创建线程和销毁线程的资源消耗,使线程可以被重复使用。
合理使用线程池的好处:
- 降低资源消耗。无需频繁创建线程和销毁。
- 提高响应速度。任务到达不需要等待线程创建就可以立即执行。
- 提高线程的可管理性。根据系统的承受能力,配置合适的线程数量。
Java里面线程池的顶级接口是 java.util.concurrent.Executor ,但是严格意义上讲 Executor 并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是 java.util.concurrent.ExecutorService 。
java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂,生成一些常用的线程池。(官方建议使用)
方法:
- public static ExecutorService newFixedThreadPool(int nThreads) :返回线程池对象。
- public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象,并执行 。
使用步骤:
- 创建线程池对象。
- 创建Runable接口子类对象。
- 获得线程池对象,执行。
- 关闭线程池。(一般不做)
代码:
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; class MyRunnable implements Runnable {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("调用了"+Thread.currentThread().getName());
}
}
public class TestRunable {
public static void main(String[] args){
//创建线程池对象
ExecutorService service = Executors.newFixedThreadPool(2);
//创建 Runable 子类对象
MyRunnable r = new MyRunnable();
//获取线程对象 调用run
for (int i =0;i<10;i++){
service.submit(r);
} }
}
温馨提示
- 如果您对本文有疑问,请在评论部分留言,我会在最短时间回复。
- 如果本文帮助了您,也请评论关注,作为对我的一份鼓励。
- 如果您感觉我写的有问题,也请批评指正,我会尽量修改。
Java基础学习(八) - 多线程的更多相关文章
- Java基础学习总结 -- 多线程的实现
目录: 继承Thread类 start()方法实现多线程的原理 实现Runnable接口 Thread类 与 Runnable接口 的联系与区别 多线程的实现方法: 继承Thread类 实现Runna ...
- Java基础学习篇---------多线程
一.编写两种多线程的方法 (1).Thread(它是继承Runnable的子类) class MyThread extends Thread{ private int ticket = 5; @Ove ...
- Java基础学习笔记总结
Java基础学习笔记一 Java介绍 Java基础学习笔记二 Java基础语法之变量.数据类型 Java基础学习笔记三 Java基础语法之流程控制语句.循环 Java基础学习笔记四 Java基础语法之 ...
- 尚学堂JAVA基础学习笔记
目录 尚学堂JAVA基础学习笔记 写在前面 第1章 JAVA入门 第2章 数据类型和运算符 第3章 控制语句 第4章 Java面向对象基础 1. 面向对象基础 2. 面向对象的内存分析 3. 构造方法 ...
- JAVA基础学习-集合三-Map、HashMap,TreeMap与常用API
森林森 一份耕耘,一份收获 博客园 首页 新随笔 联系 管理 订阅 随笔- 397 文章- 0 评论- 78 JAVA基础学习day16--集合三-Map.HashMap,TreeMap与常用A ...
- Java基础学习-- 继承 的简单总结
代码参考:Java基础学习小记--多态 为什么要引入继承? 还是做一个媒体库,里面可以放CD,可以放DVD.如果把CD和DVD做成两个没有联系的类的话,那么在管理这个媒体库的时候,要单独做一个添加CD ...
- Java基础学习中一些词语和语句的使用
在Java基础学习中,我们刚接触Java会遇到一些词和语句的使用不清的情况,不能很清楚的理解它的运行效果会是怎么样的,如:break,continue在程序中运行效果及跳转位置, 1.先来看看brea ...
- 转载-java基础学习汇总
共2页: 1 2 下一页 Java制作证书的工具keytool用法总结 孤傲苍狼 2014-06-24 11:03 阅读:25751 评论:3 Java基础学习总结——Java对象的序列化和 ...
- java基础学习总结——开篇
java是我学习的第一门编程语言,当初学习java基础的时候下了不少功夫,趁着这段时间找工作之际,好好整理一下以前学习java基础时记录的笔记,当作是对java基础学习的一个总结吧,将每一个java的 ...
随机推荐
- 【Offer】[3-1] 【找出数组中重复的数字】
题目描述 思路 Java代码 代码链接 题目描述 在一个长度为n的数组里的所有数字都在0~n-1的范围内.数组中某些数字是重复的,但不知道有几个数字重复了,也不知道每个数字重复了几次. 请找出数组中任 ...
- 通过原型继承理解ES6 extends 如何实现继承
前言 第一次接触到 ES6 中的 class 和 extends 时,就听人说这两个关键字不过是语法糖而已.它们的本质还是 ES3 的构造函数,原型链那些东西,没有什么新鲜的,只要理解了原型链等这些概 ...
- CVE-2018-14418 擦出新火花
笔者<Qftm>原文发布:https://xz.aliyun.com/t/6223 0x00 前言 最近,一次授权的渗透测试项目意外的撞出了(CVE-2018-14418)新的火花,在这里 ...
- Bootstrap4默认样式不对胃口?教你使用NPM+Webpack+SASS来定制
Bootstrap 是一个流行的前端样式库,可以方便快速的构建应用,但默认样式可能不尽人意,本文就介绍如何使用 NPM, Webpack, SASS 针对它的源码来定制自己的主题.版本使用的是 Boo ...
- 警告:Using platform encoding (GBK actually) to copy filtered resources, i.e. build is platform dependent!
执行Maven Install打包的时候,提示以下警告信息: [WARNING] Using platform encoding (GBK actually) to copy filtered res ...
- .Net基础篇_学习笔记_第五天_流程控制do-while循环
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.T ...
- jquery easyui dialog一进来直接最大化
扩展自 $.fn.window.defaults.通过 $.fn.dialog.defaults 重写默认的 defaults. 对话框(dialog)是一个特殊类型的窗口,它在顶部有一个工具栏,在底 ...
- 将dos格式文件转换为unix格式
在windows下换行符是\r\n,表示回到行首并换到下一行 而unix系统中换行符是\n 这样就存在一个问题,在windows上的文档到了unix上可能就无法使用了 针对这个情况有几种解决办法: 1 ...
- SpringMVC工程环境由tomcat切换到weblogic,访问不到静态资源
在org.springframework.web.servlet.DispatcherServlet之前加入 <servlet-mapping> <servlet-name>F ...
- Java 截取字符串中指定数据及之后数据
String resCallBackJson="12556{1{{{456858585{"; resCallBackJson = resCallBackJson.su ...