Java程序设计(高级及专题)- 多线程[通俗易懂]

Java程序设计(高级及专题)- 多线程[通俗易懂]Java程序设计(高级及专题)- 多线程

大家好,又见面了,我是你们的朋友全栈君。

在这里插入图片描述

概述

多线程是什么?为什么要用多线程?
  介绍多线程之前要介绍线程,介绍线程则离不开进程。
   进程 :是一个正在执行中的程序,每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元;
  线程:就是进程中的一个独立控制单元,线程在控制着进程的执行。一个进程中至少有一个进程。
多线程:一个进程中不只有一个线程。

  • 为什么要用多线程:
    ①、为了更好的利用cpu的资源,如果只有一个线程,则第二个任务必须等到第一个任务结束后才能进行,如果使用多线程则在主线程执行任务的同时可以执行其他任务,而不需要等待;
    ②、进程之间不能共享数据,线程可以;
    ③、系统创建进程需要为该进程重新分配系统资源,创建线程代价比较小;
    ④、Java语言内置了多线程功能支持,简化了java多线程编程。
  • 线程的生命周期:
    新建 :从新建一个线程对象到程序start() 这个线程之间的状态,都是新建状态;
    就绪 :线程对象调用start()方法后,就处于就绪状态,等到JVM里的线程调度器的调度;
    运行 :就绪状态下的线程在获取CPU资源后就可以执行run(),此时的线程便处于运行状态,运行状态的线程可变为就绪、阻塞及死亡三种状态。
    等待/阻塞/睡眠 :在一个线程执行了sleep(睡眠)、suspend(挂起)等方法后会失去所占有的资源,从而进入阻塞状态,在睡眠结束后可重新进入就绪状态。
    终止 :run()方法完成后或发生其他终止条件时就会切换到终止状态。

多线程的使用与线程锁的两种实现

  • 同步的前提:
      1、必须要有两个或者两个以上的线程。
      2、必须是多个线程使用同一个锁。
      3、必须保证同步中只能有一个线程在运行。
      4、只能同步方法,不能同步变量和类。
      5、不必同步类中所有方法,类可以拥有同步和非同步的方法。
      6、如果一个线程在对象上获得一个锁,就没有任何其他线程可以进入(该对象的)类中的任何一个同步方法。
      7、线程睡眠时,它所持的任何锁都不会释放。
  • 利弊
      好处:解决了多线程的安全问题。
      弊端:多个线程需要判断,消耗资源,降低效率。

多线程的使用

  • 多线程是java语言的一大特性,在很多特定情况下都需要用到,多线程要比单线程更加的耗内存,但多线程不一定要比单线程要快;因为线程的优先级和线程争夺资源没有任何关系, 所有启动的线程争夺资源的概率是相同的。线程速度问题详情
  • 这里我要讲解一下实现多线程的两种方式
    1、类继承Thread类 重写run方法,调用类start()方法启动。
    2、类实现runnable接口重写run方法,调用run()方法启动;

那么我们来看看多线程是怎么使用的

package com.geoji.thread;
//一个简单的多线程案例
public class ThreadDome_01 { 

public static void main(String[] args) throws Exception { 

Thread t0 = Thread.currentThread();
System.out.println(t0.getId() + "main");
thread1 t = new thread1();
t.start();
thread2 t2 = new thread2();
// 将线程2设置为守护线程
t2.setDaemon(true);
t2.start();
Runnable t3 = new thread3();
t3.run();
// t.setPriority(Thread.MAX_PRIORITY);
// ((Thread) t3).setPriority(Thread.MIN_PRIORITY);
// t.join();//等t线程结束后再执行下面的代码
System.out.println("asda");
}
}
// 第一个线程
// 继承Thread类 重写run方法
class thread1 extends Thread { 

@Override
public void run() { 

Thread t1 = Thread.currentThread();
for (int i = 0; i < 100; i++) { 

System.out.println(t1.getId() + "第一个线程" + i);
}
}
}
// 第二个线程
// 继承Thread类 重写run方法
class thread2 extends Thread { 

@Override
public void run() { 

Thread t2 = Thread.currentThread();
for (int i = 0; i < 2000; i++) { 

System.out.println(t2.getId() + "第二个线程" + i);
}
}
}
// runnable接口重写run方法
// 第三个线程
class thread3 implements Runnable { 

@Override
public void run() { 

Thread t3 = Thread.currentThread();
for (int i = 0; i < 100; i++) { 

System.out.println(t3.getId() + "第三个线程" + i);
}
}
}

线程锁的两种实现

第一种、对象锁

  • 问题描述:两个人合租,小红和小明 早上起床,小红先去厕所刷牙,刷完牙出来,小明再去刷牙 小红去上厕所,小红上完厕所出来,小明再去上厕所

话不多说,我们直接上代码,这是一个线程实体类Roommate .java

package com.geoji.thread;
/** * 同步线程(谁拿到这个类谁去执行代码) * 对象锁(给类加把锁,让类去控制线程的出入) * synchronized同步方法 */
public class Roommate extends Thread { 

static Object tolite = new Object();// 厕所管理员
Roommate(String name) { 

super(name);
}
@Override
public void run() { 

// TODO Auto-generated method stub
synchronized (tolite) { 

// 及时的让释放锁也是很关键
if ("小明".equals(Thread.currentThread().getName())) { 

brush();// 小明去刷牙
try { 

tolite.wait();//将锁释放掉
} catch (InterruptedException e) { 

// TODO Auto-generated catch block
e.printStackTrace();
}// 释放掉锁,此时小明进入等待状态
wc();
tolite.notify();// 唤醒小红
} else { 

brush();// 小红刷牙
try { 

tolite.notify();// 唤醒小明
tolite.wait();// 小红释放掉锁,此时小红进入等待状态
} catch (InterruptedException e) { 

// TODO Auto-generated catch block
e.printStackTrace();
}
wc();
}
}
}
// 刷牙
public void brush() { 

System.out.println(Thread.currentThread().getName() + "刚进去厕所刷牙");
try { 

Thread.sleep(1000);
} catch (InterruptedException e) { 

// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "刷完牙出来了");
}
// 上厕所
public void wc() { 

System.out.println(Thread.currentThread().getName() + "刚进去厕所蹲马桶");
try { 

Thread.sleep(1000);
} catch (InterruptedException e) { 

// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "蹲完马桶出来了");
}
}

接着是他的启动类RoommateRun.java

package com.geoji.thread;
/* * 同步代码块 */
public class RoommateRun { 

public static void main(String[] args) { 

Thread t1 = new Roommate("小红");
Thread t2 = new Roommate("小明");
t1.start();
t2.start();
}
}

运行结果:

		小明刚进去厕所刷牙
小明刷完牙出来了
小红刚进去厕所刷牙
小红刷完牙出来了
小明刚进去厕所蹲马桶
小明蹲完马桶出来了
小红刚进去厕所蹲马桶
小红蹲完马桶出来了

第二种、方法锁

  • 问题描述:有两个儿子,分别叫大明和小明,今年暑假妈妈在冰箱里买了50个雪糕,让两个儿子去吃,写个程序描述这一问题,并且统计出两个人各吃了多少。

同样话不多说我们直接上代码;这是一个线程实体类Son .java

package com.geoji.thread;
/* * 同步代码块 * 方法锁(谁拿到了这个方法谁去执行) */
public class Son implements Runnable{ 

private int bigNum;//描述大明吃了多少个雪糕
private int smallNum;//描述小明吃了多少个雪糕
private int count=50;//雪糕总数
private boolean isGoon=true;//用来控制声明时候结束吃雪糕
//吃雪糕的方法
public synchronized void eat(){ 

if(count<=0){ 

isGoon=false;
return;
}
count--;
if("大明".equals(Thread.currentThread().getName())){ 

bigNum++;
System.out.println("大明吃了第"+(50-this.count)+"根雪糕");
}else{ 

smallNum++;
System.out.println("小明吃了第"+(50-this.count)+"根雪糕");
}
try { 

Thread.sleep(100);
} catch (InterruptedException e) { 

// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Override
public void run() { 

// TODO Auto-generated method stub
while(isGoon){ 

eat();
}
}
public void show(){ 

System.out.println("大明吃了"+bigNum);
System.out.println("小明吃了"+smallNum);
}
}

接着是他的启动类SonRun.java

package com.geoji.thread;
public class SonRun { 

public static void main(String[] args) { 

Son r1=new Son();
Thread t1=new Thread(r1,"大明");
Thread t2=new Thread(r1, "小明");
t1.start();
t2.start();
try { 

t1.join();//等待线程结束
t2.join();
} catch (InterruptedException e) { 

// TODO Auto-generated catch block
e.printStackTrace();
}
r1.show();
}
}

总结:晓宇感觉在实体运用中,对象锁和方法锁没多大区别,大家可以哪个用着顺手用哪个,不过还是要具体问题具体分析,同样要根据公司项目来决定,当然在刚入职的小白来说,没有三年五载的你压根不用去考虑线程的问题,因为java基本上都是开发企业的项目,正常来说不是什么金融银行的工程,用不上线程锁这种东西,但我们作为一个开发人员还是要知道的,下面是晓宇对锁的理解。

  • A. 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的, 则它取得的锁是对象;如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。
  • B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。
  • C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。

资源下载

死锁

进程A中包含资源A,进程B中包含资源B,A的下一步需要资源B,B的下一步需要资源A,所以它们就互相等待对方占有的资源释放,所以也就产生了一个循环等待死锁。

  public class DeadLock { 

public static void main(String[] args) { 

Thread t1 = new Thread(new DeadLockTest(true));
Thread t2 = new Thread(new DeadLockTest(false));
t1.start();
t2.start();
}
}
class DeadLockTest implements Runnable{ 

private boolean flag;
static Object obj1 = new Object();
static Object obj2 = new Object();
public DeadLockTest(boolean flag) { 

this.flag = flag;
}
public void run(){ 

if(flag){ 

synchronized(obj1){ 

System.out.println("if lock1");
synchronized (obj2) { 

System.out.println("if lock2");
}
}
}else{ 

synchronized (obj2) { 

System.out.println("else lock2");
synchronized (obj1) { 

System.out.println("else lock1");
}
}
}
}
}

死锁形成的必要条件总结(都满足之后就会产生):
    ①、互斥条件:资源不能被共享,只能被同一个进程使用;
    ②、请求与保持条件:已经得到资源的进程可以申请新的资源;
    ③、非剥夺条件:已经分配的资源不能从相应的进程中强制剥夺;
    ④、循环等待条件:系统中若干进程形成环路,该环路中每个进程都在等待相邻进程占用的资源。

线程池

Java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

线程池的作用:

线程池作用就是限制系统中执行线程的数量。
根 据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果;少了浪费了系统资源,多了造成系统拥挤效率不高。用线程池控制线程数量,其他线程排 队等候。一个任务执行完毕,再从队列的中取最前面的任务开始执行。若队列中没有等待进程,线程池的这一资源处于等待。当一个新任务需要运行时,如果线程池 中有等待的工作线程,就可以开始运行了;否则进入等待队列。

为什么要用线程池:
1.减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。
2.可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。
Java里面线程池的顶级接口是Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

  • 比较重要的几个类:
    ExecutorService: 真正的线程池接口。
    ScheduledExecutorService: 能和Timer/TimerTask类似,解决那些需要任务重复执行的问题。
    ThreadPoolExecutor: ExecutorService的默认实现。
    ScheduledThreadPoolExecutor: 继承ThreadPoolExecutor的ScheduledExecutorService接口实现,周期性任务调度的类实现。
    要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在Executors类里面提供了一些静态工厂,生成一些常用的线程池。
  • newCachedThreadPool:
public static void main(String[] args) { 
  
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
for (int i = 0; i < 10; i++) { 
  
final int index = i;  
try { 
  
Thread.sleep(10);  
} catch (InterruptedException e) { 
  
e.printStackTrace();  
}  
cachedThreadPool.execute(new Runnable() { 
  
public void run() { 
  
System.out.println(index);  
}  
});  
}  

newFixedThreadPool:

public static void main(String[] args) { 
  
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
for (int i = 0; i < 10; i++) { 
  
final int index = i;  
fixedThreadPool.execute(new Runnable() { 
  
public void run() { 
  
try { 
  
System.out.println(index);  
Thread.sleep(10);  
} catch (InterruptedException e) { 
  
e.printStackTrace();  
}  
}  
});  
}  
}  

定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors().
newScheduleThreadPool()

public static void main(String[] args) { 
  
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
for (int i = 0; i < 10; i++) { 
  
scheduledThreadPool.schedule(new Runnable() { 
  
public void run() { 
  
System.out.println("delay 3 seconds");  
}  
}, 3, TimeUnit.SECONDS);  
}  
} 

newSingleThreadExecutor
按顺序执行线程,某个时间段只能有一个线程存在,一个线程死掉,另一个线程会补上

public static void main(String[] args) { 
  
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
for (int i = 0; i < 10; i++) { 
  
final int index = i;  
singleThreadExecutor.execute(new Runnable() { 
  
public void run() { 
  
/* System.out.println(index);*/  
try { 
  
System.out.println(index);  
Thread.sleep(2000);  
} catch (InterruptedException e) { 
  
e.printStackTrace();  
}  
}  
});  
}  
}  

线程池Demo

package thread.demo.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
class MyThread extends Thread{ 

public void run(){ 

System.out.println(Thread.currentThread().getName()+"is running");
}
}
//class MyThread1 implements Runnable{ 

// public void run(){ 

// System.out.println("====");
// }
//}
public class ThreadPoolDemo { 

/** * @param args */
public static void main(String[] args) { 

// TODO Auto-generated method stub
// ExecutorService pool=Executors.newFixedThreadPool(3);
Thread t1=new MyThread();
Thread t2=new MyThread();
Thread t3=new MyThread();
Thread t4=new MyThread();
Thread t5=new MyThread();
// pool.execute(t1);
// pool.execute(t2);
// pool.execute(t3);
// pool.execute(t4);
// pool.execute(t5);
// pool.shutdown();
/* * output: * pool-1-thread-2is running * pool-1-thread-3is running * pool-1-thread-1is running * pool-1-thread-3is running * pool-1-thread-2is running * */
// ExecutorService pool1=Executors.newCachedThreadPool();
// pool1.execute(t1);
// pool1.execute(t2);
// pool1.execute(t3);
// pool1.execute(t4);
// pool1.execute(t5);
// pool1.shutdown();
/* * output: * pool-2-thread-2is running * pool-2-thread-3is running * pool-2-thread-1is running * pool-2-thread-4is running * pool-2-thread-5is running */
// ExecutorService pool2=Executors.newSingleThreadExecutor();
// pool2.execute(t1);
// pool2.execute(t2);
// pool2.execute(t3);
// pool2.execute(t4);
// pool2.execute(t5);
// pool2.shutdown();
/* * OutPut: * pool-3-thread-1is running * pool-3-thread-1is running * pool-3-thread-1is running * pool-3-thread-1is running * pool-3-thread-1is running */
ExecutorService pool3=Executors.newScheduledThreadPool(1);
pool3.execute(new Runnable(){ 

public void run(){ 

System.out.println(Thread.currentThread().getName()+"====");
}
});
pool3.execute(new Runnable(){ 

public void run(){ 

System.out.println(Thread.currentThread().getName()+"~~~~");
}
});
pool3.shutdown();
/* * output: * pool-3-thread-1==== * pool-3-thread-1~~~~ */
}
}

线程速度问题

单线程不一定比多线程要快。
比如打印十条输出语句,单线程就是把十条语句串在成一条长绳上,去完成它;多线程就是拆成10条短绳去完成它,此时多线程要快于单线程;
如果做十个修改操作时,多线程要考虑先后修改的操作者是谁,而单线程只要完成修改后的结果,此时单线程要快于多线程;
总结单线程与多线程速度快慢问题时,要具体问题具体分析。
多线程要比单线程更加的占用内存资源,从而去抢占cpu资源;与cpu处理的效率无关。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/106663.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • top命令 详解_top命令的用法

    top命令 详解_top命令的用法top命令是Linux下常用的性能分析工具,能够实时显示系统中各个进程的资源占用状况,类似于Windows的任务管理器。下面详细介绍它的使用方法。top是一个动态显示过程,即可以通过用户按键来不断刷新当前状态.如果在前台执行该命令,它将独占前台,直到用户终止该程序为止.比较准确的说,top命令提供了实时的对系统处理器的状态监视.它将显示系统中CPU最“敏感”的任务列表.该命令可以按CPU使用.内存使用和执行时间对任务进行排序;而且该命令的很多特性都可以通过交互式命令或者在个人定制文件中进行设定.1...

  • vue 使用数组splice方法失效,且总是删除最后一项的解决办法。[通俗易懂]

    vue 使用数组splice方法失效,且总是删除最后一项的解决办法。[通俗易懂]今天在写项目的时候,遇到一个很简单的需求,下图,点击添加标签,左边出现一个可以输入的标签,点击删除按钮,就能删除当前标签,很简单的需求,我却搞了一个多小时(哎…新手愚笨啊)一看到这个我的思路就是点击添加标签,把新增的节点push到自己定义的数组里,然后渲染出来,点击删除按钮,用splice方法从数组中删除掉当前的节点(很简单,很明确的思路嘛,但是却事与愿违) <div…

  • C#验证二代身份证号码

    C#验证二代身份证号码身份证号码的验证及15位升18位算法18位身份证标准在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》中做了明确的规定。GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修订版,其中指出将原标准名称”社会保障号码”更名为”公民身份号码”,另外GB11643-1999《公民身份号码》从实施之日起代替GB11643-1989。

  • android之通过Button的监听器往adapter中添加数据时出错

    本来源代码如下: List model; //自定义的一个List数据,存储的是自定义的类 LunchListAdapter adapter;//自定义的一个ListView的适配器 ……//省略class onSavaLis implements OnClickListener{ //Button s

  • HashMap多线程下发生死循环的原因

    HashMap多线程下发生死循环的原因

  • J1939TP「建议收藏」

    J1939TP「建议收藏」J1939TP给上层、下层提供的服务,和它本身内部的行为。1939协议定义了一些参数组,每个参数组包含确定的内容和信号。并提供以下PG:负载的长度类型:最大字节数、可变或固定大小参数组号:18位包含以下信息:2bit数据页信息8bitPDU格式8bitPDU细节PF小于240的为PDU1格式,用于点对点通信;大于等于240的为PDU2格式,用于广播通信。PDU细节仅与PDU2格式有关。在PDU1格式下的点对点通信,PS总为0。J1939使用29位CANid作为消…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号