多线程介绍
多线程中的基本概念
程序(Program)是一个静态的概念,一般对应于操作系统中的一个可执行文件。
执行中的程序叫做进程(Process),是一个动态的概念,其实进程就是一个在内存中独立运行的程序空间。
现代操作系统比如Mac OS X,Linux,Windows等,都是支持“多任务”的操作系统。**操作系统可以同时运行多个任务。**比如,一边在用逛淘宝,一边在听音乐,一边用微信聊天,至少同时有3个任务正在运行。还有很多任务悄悄在后台同时运行着,只是在桌面上没有显示。
线程(Thread)是操作系统能够进行运算调度的最小单位,被包含在进程之中,是进程中的实际运作单位。
在一个进程内部,要同时干多件事,需要同时运行多个“子任务”,这些“子任务”称为线程(Thread)
进程与线程的区别
乔布斯想开工厂生成手机,费劲力气,制作一条生成线,这个生产线上有很多的器件以及材料。一条生产线就是一个进程。
只有生产线是不够的,所以找五个工人来进行生产,这个工人能够利用这些材料最终一步步的将手机做出来,这五个工人就是五个线程。
为了提高生产率,有两种办法:
- 一条生产线上多招些工人,一起来做手机,这样效率是成倍増长,即单进程多线程方式
- 多条生产线,每个生产线上多个工人,即多进程多线程
- 线程是程序执行的最小单位,进程是操作系统分配资源的最小单位
- 一个进程由一个或多个线程组成,线程是一个进程中代码的不同执行路线
- 进程之间互相独立,但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号),某进程内的线程在其他进程不可见。
- 调度和切换:线程上下文切换比进程上下文切换要快。
什么是并发
并发是指在一段时间内同时做多个事情。当多个线程在运行时,如果只有一个CPU,这种情况下计算机操作系统会采用并发技术实现并发运行,具体作废是采用“时间片轮循算法”,在一个时间段的线程代码运行时,其他代码处于就绪状。这种方式称之为并发。(Concurrent)
串行(serial):一个CPU上,按顺序完成多个任务
并行(parallelism):指的是任务数小于等于CPU核数,即任务真的是一起执行的。
并发(concurrency):一个CPU采用时间片管理方式交替的处理多个任务。一般是任务数多余cpu核数,通过操作系统的各种任务调度算法,实现用多个任务“一起”执行
(实际上总有一些任务不在执行,因为切换任务速度相当快,看上去一起执行而已)
线程的执行特点
方法的执行特点
线程的执行特点
什么是主线程以及子线程
**主线程:**当Java程序启动时,一个线程会立刻运行,该线程通常叫程序的主线程(main thread),即main方法对应的线程,它是程序开始时就执行的。
java应用程序会有一个main方法。是作为某个类的方法出现的,当程序启动时,该方法就会第一个自动得到执行,并成为程序的主线程。main方法是一个应用的入口,代表了该应用的主线程。JVM在执行main方法时,该方法会进入栈内存,JVM会通过操作系统开辟一条main方法通向cpu的执行路径,cpu就可以通过这个路径来执行main方法,而该路径就叫主线程。
**特点:**是产生其他子线程的线程。不一定是最后完成执行的线程,子线程可能在它结束之后还在运行。
**子线程:**在主线程中创建并启动的线程。
线程的创建
通过继承Thread类实现多线程
继承Thread类实现多线程的步骤:
- 在Java中负责实现线程功能的类是java.lang.Thread类该,该方式的缺点是如果类已经继承了一个类(如小程序必须继承自Applet类),则无法再继承Thread类
- 通过创建Thread的实例来创建新的线程
- 每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作,方法run()称为线程体。
- 通过调用Thread类的start()方法来启动一个线程。
package com.itbaizhan.com.itbaizhan.Thread;
public class TestThread extends Thread{
//自定义类继承Thread类
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(this.getName()+":"+i);
//getName()方法是返回线程名称
}
}
public static void main(String[] args) {
TestThread thread1=new TestThread();//创建线程对象
thread1.start();//启动线程
TestThread thread2=new TestThread();
thread2.start();
}
}
通过Runnable接口实现多线程
在开发中,应用更多的是通过Runnable接口实现多线程,这种方式克服了继承Thread类的缺点,在实现Runnable接口的同时还可以继承某个类。
从源码的角度看,Thread类也是实现了Runnable接口,Runnable接口的源码如下:
public interface Runnable{
void run();
}
通过Runnable接口实现多线程
package com.itbaizhan.com.itbaizhan.Thread;
//自定义类实现Runnable接口
public class TestThread2 implements Runnable{
@Override
//run()方法里是线程体
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
//创建线程对象,把实现了Runnable接口的对象作为参数传入
Thread thread1=new Thread(new TestThread2());
thread1.start();
Thread thread2=new Thread(new TestThread2());
thread2.start();
}
}
线程的执行流程
线程状态和生命周期
一个线程对象在它的生命周期内,需要经历5个状态。
- 新生状态(New)
用new关键字建立一个线程对象后,该线程对象处于新生状态。处于新生状态的线程有自己的内存空间,通过调用start方法进入就绪状态。 - 就绪状态(Runnable)
处于就绪状态的线程已经具备了运行条件,但是还没有被分配到CPU,处于“线程就绪队列”,等待系统为其分配CPU。就绪状态并不是执行状态,当系统选定一个等待执行的Thread对象后,就会进入执行状态。一旦获得cpu,线程就会进入运行状态并自动调用自己的run方法, - 运行状态(Running)
- 阻塞状态(Blocked)
- 死亡状态(Terminated)
线程的使用
终止线程的典型方式
终止线程我们一般不使用JDK提供的stop()/destory()方法(本身已被JDK废弃),通常的做法是提供一个boolean型的终止变量,当这个变量置为false,则终止线程的运行。
package com.itbaizhan.Thread;
public class StopThread implements Runnable {
private boolean flag=true;
@Override
public void run() {
System.out.println(Thread.currentThread().getName()
+"线程开始");
int i=0;
while (flag){
System.out.println(Thread.currentThread().getName()
+" "+i++);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()
+"线程结束");
}
public void stop(){
this.flag=false;
}
public static void main(String[] args) throws Exception {
System.out.println("主线程开始");
StopThread st=new StopThread();
Thread t1=new Thread(st);
t1.start();
System.in.read();
st.stop();
System.out.println("主线程结束");
}
}
线程休眠
sleep()方法:可以让正在运行的线程进入阻塞状态,直到休眠时间满了,进入就绪状态。参数为休眠的毫秒数。
package com.itbaizhan.Thread;
public class SleepThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程开始");
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
try {
Thread.sleep(1000);//线程休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"线程结束");
}
public static void main(String[] args) {
System.out.println("主线程开始");
Thread t=new Thread(new SleepThread());
t.start();
System.out.println("主线程结束");
}
}
线程让步
yield()让当前正在运行的线程回到就绪状态,以允许具有相同优先级的其他线程获得运行的机会。因此,使用yield()的目的是让具有相同优先级的线程之间能够适当地轮换执行。但是,实际中无法保证yield()达到让步的目的,因为让步的线程可能被线程调度程序再次选中。
使用yield方法时要注意的几点:
- yield是一个静态的方法
- 调用yield后,yield告诉当前线程把运行机会交给具有相同优先级的线程。
- yield不能保证,当前线程迅速从运行状态切换到就绪状态。
- yield只能是将当前线程从运行状态切换到就绪状态,而不能是等待或者阻塞状态。
package com.itbaizhan.Thread;
public class TestYieldThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 30; i++) {
if("Thread-0".equals(Thread.currentThread().getName())){
if(i==0){
Thread.yield();
}
}
System.out.println(Thread.currentThread().getName()+" "+i);
}
}
public static void main(String[] args) {
Thread t1=new Thread(new TestYieldThread());
Thread t2=new Thread(new TestYieldThread());
t1.start();
t2.start();
}
}
线程联合
当前线程邀请调用方法的线程优先执行,在调用方法的线程执行结束之前,当前线程不能再次执行。线程A在运行期间,可以调用线程B的join()方法,让线程B和线程A联合。线程A就必须等待线程B执行完毕后才能继续执行。通过线程的联合,可以使线程由并行变为串行。
join方法的使用
join()方法就是指调用该方法的线程在执行完run()方法后,再执行join方法后面的代码,即将两个线程合并,用于实现同步控制。
package com.itbaizhan.Thread;
class A implements Runnable{
private Thread b;
public A(Thread b){
this.b=b;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()
+" A "+i);
if(i==5){
try {
this.b.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class B implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()
+" B "+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class TestJoinThread{
public static void main(String[] args) {
Thread t1=new Thread(new B());
Thread t=new Thread(new A(t1));
t.start();
t1.start();
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()
+" "+i);
if(i==2){
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
线程联合案例
实现爸爸让孩子买烟
package com.itbaizhan.Thread;
//儿子买烟线程
class SonThread implements Runnable{
@Override
public void run() {
System.out.println("儿子出门买烟");
System.out.println("儿子出门买烟需要10分钟");
for (int i = 0; i < 10; i++) {
System.out.println("第"+i+"分钟");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("儿子买烟回来了");
}
}
//爸爸抽烟线程
class FatherThread implements Runnable{
@Override
public void run() {
System.out.println("爸爸想抽烟发现烟抽完了");
System.out.println("爸爸让儿子去买一包烟");
Thread t=new Thread(new SonThread());
t.start();
System.out.println("等待儿子买烟回来");
try {
t.join();//调用该方法的线程在执行完run()方法后,
// 再执行join方法后面的代码,即将两个线程合并,用于实现同步控制。
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("爸爸出门找儿子");
System.exit(1);
System.out.println("爸爸高兴接过烟并把零钱给儿子");
}
}
}
public class TestJoinDemo {
public static void main(String[] args) {
System.out.println("爸爸和儿子买烟");
Thread t=new Thread(new FatherThread());
t.start();
}
}
获取线程名称
- this.getName()获取线程名称,该方法适用于继承Thread实现多线程方式
class GetName1 extends Thread{
@Override
public void run(){
System.out.println(this.getName());
}
}
- Thread.currentThread().getName()获取线程名称,该方法适用于实现Runnable接口实现多线程方式。
class GetName2 implements Runnable{
@Override
public void run(){
System.out.println(Thread.currentThread().getName());
}
}
修改线程名称
- 通过构造方法设置线程名称
class SetName1 extends Thread{
public SetName1(String name){
super(name);
}
@Override
public void run(){
System.out.println(this.getName);
}
}
public class SetNameThread{
public static void main(String[] args) {
SetName1 setName1=new SetName1("SetName1");
serName1.start();
}
}
- 通过setName()方法设置线程名称
package com.itbaizhan.Thread;
class SetName2 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
public class SetNameThread {
public static void main(String[] args) {
Thread thread=new Thread(new SetName2());
thread.setName("SetName2");
thread.start();
}
}
判断线程是否存活
isAlive()方法:判断当前的线程是否处于活动状态。
活动状态是指线程已经启动且尚未终止,线程处于正在运行或准备开始运行的状态,就认为线程是存活的。
package com.itbaizhan.Thread;
class Alive implements Runnable{
@Override
public void run() {
for (int i = 0; i < 4; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class TestAliveThread {
public static void main(String[] args) {
Thread thread=new Thread(new Alive());
thread.setName("Alive");
thread.start();
System.out.println(thread.getName()+" "+thread.isAlive());
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(thread.getName()+" "+thread.isAlive());
}
}
线程的优先级
线程优先级介绍
含义:每一个线程都有优先级,可为每个线程定义线程的优先级,但是并不能保证高优先级的线程会在低优先级的线程前执行。线程的优先级用数字表示,范围从1到10,一个线程的缺省优先级是5。
Java的线程优先级调度会委托给操作系统去处理,所以与具体的操作系统的优先级有关,如果不是特别需要,一般无需设置线程优先级。
线程的优先级高则优先执行的概率高,并不是优先执行。
线程优先级的使用
使用下列方法获得或设置线程对象的优先级
- int getPriority()
- void setPriority(int newPriority)
优先级低只意味着获得调度的概率低,并不是绝对先调用优先级高的线程后调用优先级低的线程
package com.itbaizhan.Thread;
class Priority implements Runnable{
private int num=0;
private boolean flag=true;
@Override
public void run() {
while (this.flag){
System.out.println(Thread.currentThread().getName()+" "+num++);
}
}
public void stop(){
this.flag=false;
}
}
public class PriorityThread {
public static void main(String[] args) throws Exception {
Priority p1=new Priority();
Priority p2=new Priority();
Thread t1=new Thread(p1,"线程1");//创造线程t1,并将自己定义的类作为参数传递
Thread t2=new Thread(p2,"线程2");
System.out.println(t1.getPriority());
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
Thread.sleep(1000);
p1.stop();
p2.stop();
}
}
守护线程
守护线程的介绍
在Java中有两类线程:
- User Thread(用户线程):应用程序里的自定义线程
- Daemon Thread(守护线程):比如垃圾回收线程,就是最典型的守护线程。
守护线程(Daemon Thread):是一个服务线程,服务用户线程。
特点:守护线程会随着用户线程的死亡而死亡
守护线程和用户线程的区别: - 用户线程不随着主线程的死亡而死亡,用户线程只有两种情况会死掉,在run中异常终止,正常把run执行完毕,线程死亡。
- 守护线程会随着用户线程的死亡而死亡,当用户线程死亡守护线程也会随之死亡。
守护线程的使用
线程同步
package com.itbaizhan.Thread;
//守护线程类
class Daemon implements Runnable{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()
+" "+i);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class UserThread implements Runnable{
@Override
public void run() {
Thread t=new Thread(new Daemon(),"Daemon");
//将该线程设置为守护线程
t.setDaemon(true);
//启动线程
t.start();
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class DaemonThread {
public static void main(String[] args) throws Exception {
Thread t=new Thread(new UserThread(),"UserThread");
t.start();
Thread.sleep(1000);
System.out.println("主线程结束");
}
}
线程同步介绍
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,就需要使用到“线程同步”,线程同步是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面的线程使用完毕后,下一个线程再使用。
线程冲突案例演示
银行取款的基本流程可以分为:
- 用户输入账户、密码,系统判断用户的账户、密码是否匹配
- 用户输入取款金额
- 系统判断账户余额是否大于或等于取款金额
- 如果余额大于或等于取款金额,则取钱成功;如果余额小于取款金额,则取钱失败。
该代码块不能实现两个人同时取款并扣除余额的情况即一共1000元,A线程可取800,B线程也可取800
package com.itbaizhan.Thread;
//账户类
class Account {
//账号
private String accountNo;
//账户余额
private double balance;
public Account() {
}
public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
//取款类
class DrawThread implements Runnable {
private Account account;
private double drawMoney;
public DrawThread(Account account, double drawMoney) {
this.account = account;
this.drawMoney = drawMoney;
}
//取款线程
@Override
public void run() {
//判断当前账户余额是否大于等于取款金额
if (this.account.getBalance() >= this.drawMoney) {
System.out.println(Thread.currentThread().getName() + " 取钱成功,吐出钞票:" + this.drawMoney);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//更新账户余额
this.account.setBalance(this.account.getBalance() - this.drawMoney);
System.out.println("\t 余额为:" + this.account.getBalance());
} else {
System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足");
}
}
}
public class TestDrawMoneyThread {
public static void main(String[] args) {
Account account = new Account("1234", 1000);
new Thread(new DrawThread(account, 800), "小红帽").start();
new Thread(new DrawThread(account, 800), "大灰狼").start();
}
}
实现线程同步
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突的问题。Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问造成的问题,该机制就是synchronized关键字。
synchronized语法结构:
synchronized(锁对象){
同步代码
}
注意事项:
- 部分代码在执行时具有线程互斥的能力(线程互斥:并行变串行)
- 线程中的代码具有互斥能力(通过synchronized锁对象来决定)
两种用法:
synchronized方法和synchronized块 - synchronized方法
通过在方法声明中加入synchonized关键字来声明,语法:
public synchronized void accessVal(int newVal);
**synchronized在方法声明时使用:**放在访问控制符(public)之前或之后,这时同一个对象下synchronized方法在多线程中执行时,该方法是同步的,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入。
synchronized块
synchronized方法的缺陷:若将一个大的方法声明为synchronized将会大大影响效率
Java为我们提供了更好的解决办法,那就是synchronized块。块可以让我们精确地控制到具体的“成员变量”,缩小同步的范围,提高效率。
修改线程冲突案例演示
package com.itbaizhan.Thread;
//账户类
class Account {
//账号
private String accountNo;
//账户余额
private double balance;
public Account() {
}
public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
//取款类
class DrawThread implements Runnable {
private Account account;
private double drawMoney;
public DrawThread(Account account, double drawMoney) {
this.account = account;
this.drawMoney = drawMoney;
}
//取款线程
@Override
public void run() {
synchronized (this.account) {
//由于是两个人同时取余额,容易造成余额冲突,则余额对象应该是需要同步的对象
//判断当前账户余额是否大于等于取款金额
if (this.account.getBalance() >= this.drawMoney) {
System.out.println(Thread.currentThread().getName() + " 取钱成功,吐出钞票:" + this.drawMoney);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//更新账户余额
this.account.setBalance(this.account.getBalance() - this.drawMoney);
System.out.println("\t 余额为:" + this.account.getBalance());
} else {
System.out.println(Thread.currentThread().getName() + "取钱失败,余额不足");
}
}
}
}
public class TestDrawMoneyThread {
public static void main(String[] args) {
Account account = new Account("1234", 1000);
new Thread(new DrawThread(account, 800), "小红帽").start();
new Thread(new DrawThread(account, 800), "大灰狼").start();
}
}
使用this作为线程对象锁
在所有线程中,相同对象中的synchronized会互斥。
语法结构:
package com.itbaizhan.Thread;
//定义程序员类
class Programmer {
private String name;
public Programmer(String name) {
this.name = name;
}
//打开电脑
synchronized public void computer() {
try {
System.out.println(this.name + "接通电源");
Thread.sleep(500);
System.out.println(this.name + "按开机按键");
Thread.sleep(500);
System.out.println(this.name + "系统启动中");
Thread.sleep(500);
System.out.println(this.name + "启动成功");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//编码
synchronized public void coding() {
try {
System.out.println(this.name + "双击IDEA");
Thread.sleep(500);
System.out.println(this.name + "IDEA启动完毕");
Thread.sleep(500);
System.out.println(this.name + "开开心心的写代码");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//打开电脑的工作线程
class Working1 extends Thread{
private Programmer p;
public Working1( Programmer p) {
this.p = p;
}
@Override
public void run() {
this.p.computer();
}
}
//编写代码的工作流程
class Working2 extends Thread{
private Programmer p;
public Working2(Programmer p){
this.p=p;
}
@Override
public void run() {
this.p.coding();
}
}
public class TestSyncThread {
public static void main(String[] args) {
Programmer p=new Programmer(“小龙女”);
new Working1§.start();
new Working2§.start();
}
}
package com.itbaizhan.Thread;
//定义程序员类
class Programmer {
private String name;
public Programmer(String name) {
this.name = name;
}
//打开电脑
synchronized public void computer() {
try {
System.out.println(this.name + "接通电源");
Thread.sleep(500);
System.out.println(this.name + "按开机按键");
Thread.sleep(500);
System.out.println(this.name + "系统启动中");
Thread.sleep(500);
System.out.println(this.name + "启动成功");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//编码
synchronized public void coding() {
try {
System.out.println(this.name + "双击IDEA");
Thread.sleep(500);
System.out.println(this.name + "IDEA启动完毕");
Thread.sleep(500);
System.out.println(this.name + "开开心心的写代码");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//打开电脑的工作线程
class Working1 extends Thread{
private Programmer p;
public Working1( Programmer p) {
this.p = p;
}
@Override
public void run() {
this.p.computer();
}
}
//编写代码的工作流程
class Working2 extends Thread{
private Programmer p;
public Working2(Programmer p){
this.p=p;
}
@Override
public void run() {
this.p.coding();
}
}
public class TestSyncThread {
public static void main(String[] args) {
Programmer p=new Programmer("小龙女");
new Working1(p).start();
new Working2(p).start();
}
}
使用字符串作为线程对象锁
所有线程在执行synchronized时都会同步。
synchronized("字符串"){
//同步代码
}
package com.itbaizhan.Thread;
//定义程序员类
class Programmer {
private String name;
public Programmer(String name) {
this.name = name;
}
//打开电脑
synchronized public void computer() {
try {
System.out.println(this.name + "接通电源");
Thread.sleep(500);
System.out.println(this.name + "按开机按键");
Thread.sleep(500);
System.out.println(this.name + "系统启动中");
Thread.sleep(500);
System.out.println(this.name + "启动成功");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//编码
synchronized public void coding() {
try {
System.out.println(this.name + "双击IDEA");
Thread.sleep(500);
System.out.println(this.name + "IDEA启动完毕");
Thread.sleep(500);
System.out.println(this.name + "开开心心的写代码");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//去卫生间
public void wc(){
synchronized ("suibian"){
try {
System.out.println(this.name+"打开卫生间门");
Thread.sleep(500);
System.out.println(this.name+"开始排泄");
Thread.sleep(500);
System.out.println(this.name+"冲水");
Thread.sleep(500);
System.out.println(this.name+"离开卫生间");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//打开电脑的工作线程
class Working1 extends Thread{
private Programmer p;
public Working1( Programmer p) {
this.p = p;
}
@Override
public void run() {
this.p.computer();
}
}
//编写代码的工作流程
class Working2 extends Thread {
private Programmer p;
public Working2(Programmer p) {
this.p = p;
}
@Override
public void run() {
this.p.coding();
}
}
//取卫生间的线程
class WC extends Thread{
private Programmer p;
public WC(Programmer p){
this.p=p;
}
@Override
public void run() {
this.p.wc();
}
}
public class TestSyncThread {
public static void main(String[] args) {
Programmer p=new Programmer("小龙女");
Programmer p1=new Programmer("杨过");
Programmer p2=new Programmer("张敏");
new WC(p1).start();
new WC(p2).start();
new WC(p).start();
}
}
使用Class作为线程对象锁
在所有线程中,拥有相同Class对象中的synchronized会互斥
synchronized(XX.class){
//同步代码
}
或
synchronized public static void accessVal()
package com.itbaizhan.Thread;
//定义销售员工类
class Sale{
private String name;
public Sale(String name){
this.name=name;
}
//领取奖金
synchronized public static void money(){
try {
System.out.println(Thread.currentThread().getName()+" 被领导表扬");
Thread.sleep(500);
System.out.println(Thread.currentThread().getName()+" 拿钱");
Thread.sleep(500);
System.out.println(Thread.currentThread().getName()+" 对公司表示感谢");
Thread.sleep(500);
System.out.println(" 开开心心拿钱走人");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//销售部门领取奖金线程类
class SaleMoney extends Thread{
private Sale p;
public SaleMoney(Sale p){
this.p=p;
}
@Override
public void run() {
this.p.money();
}
}
public class TestSyncThread1 {
public static void main(String[] args) {
Sale s=new Sale("孙悟空");
Sale s1=new Sale("猪八戒");
new SaleMoney(s).start();
new SaleMoney(s1).start();
}
}
使用自定义对象作为线程对象锁
在所有线程中,拥有相同自定义对象中的synchronized会互斥。
语法结构
synchronized(自定义对象){
//同步代码
}
package com.itbaizhan.Thread;
//定义销售员工类
class Sale {
private String name;
public Sale(String name) {
this.name = name;
}
}
//定义经理类
class Manager{
private String name;
public Manager(String name) {
this.name = name;
}
public String getName(){
return this.name;
}
public void cheers(String mName,String eName){
try {
System.out.println(eName+" 来到 "+mName+" 面前");
Thread.sleep(500);
System.out.println(eName+"拿起酒杯");
Thread.sleep(500);
System.out.println(mName+" 和 "+eName+" 干杯");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//敬酒线程类
class CheersThread extends Thread{
private Manager manager;
private String name;
public CheersThread(String name,Manager manager){
this.name=name;
this.manager=manager;
}
@Override
public void run() {
synchronized (this.manager){
this.manager.cheers(this.manager.getName(),name);
}
}
}
public class TestSyncThread1 {
public static void main(String[] args) {
Manager manager=new Manager("贾宝玉");
new CheersThread("林黛玉",manager).start();
new CheersThread("薛宝钗",manager).start();
}
}
什么是线程死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能进行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形。
某一个同步块需要同时拥有“两个以上对象的锁”时,就可能会发生“死锁”问题。两个线程就形成了互相等待,无法继续运行的“死锁状态”。
线程死锁案例演示
package com.itbaizhan.Thread;
/**
* 化妆线程同时需要拥有一个镜子对象、一个口红对象才能运行同步块。那么实际运行时,总共只有一个镜子对象和一个口红对象
* 小丫的化妆线程拥有了镜子对象,大丫的化妆线程拥有了口红对象,
* 都在互相等待对方释放资源,才能化妆。
* 这样两个线程就形成了互相等待,无法继续运行的“死锁状态”
*/
//口红类
class Lipstick{
}
//镜子类
class Mirror{
}
//化妆线程类
class Makeup extends Thread{
private int flag;//flag=0:拿着口红
//flag!=0:拿着镜子
private String girlName;
static Lipstick lipstick=new Lipstick();
static Mirror mirror=new Mirror();
public Makeup() {
}
public Makeup(String name, int flag, String girlName) {
this.flag = flag;
this.girlName = girlName;
}
public int getFlag() {
return flag;
}
public void setFlag(int flag) {
this.flag = flag;
}
public String getGirlName() {
return girlName;
}
public void setGirlName(String girlName) {
this.girlName = girlName;
}
//开始化妆
public void doMakeup() {
if (flag == 0) {
synchronized (lipstick) {
System.out.println(this.girlName + "拿着口红");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (mirror) {
System.out.println(this.girlName + "拿着镜子");
}
}
}else {
synchronized (mirror){
System.out.println(this.girlName+" 拿着镜子");
try{
Thread.sleep(2000);
}catch (Exception e){
e.printStackTrace();
}
synchronized (lipstick){
System.out.println(this.girlName+" 拿着口红");
}
}
}
}
@Override
public void run() {
this.doMakeup();
}
}
public class DeadLockThread {
public static void main(String[] args) {
Makeup makeup=new Makeup();
makeup.setFlag(0);//拥有口红
makeup.setGirlName("大丫");
Makeup makeup1=new Makeup();
makeup1.setFlag(1);//拥有镜子
makeup1.setGirlName("小丫");
makeup.start();
makeup1.start();
}
}
线程死锁问题的解决
死锁是由于“同步块需要同时持有多个对象锁造成的”,解决的办法是同一个代码块不要同时持有两个对象锁。
package com.itbaizhan.Thread;
/**
* 同一个代码块,不要同时持有两个对象锁。
*/
//口红类
class Lipstick{
}
//镜子类
class Mirror{
}
//化妆线程类
class Makeup extends Thread{
private int flag;//flag=0:拿着口红
//flag!=0:拿着镜子
private String girlName;
static Lipstick lipstick=new Lipstick();
static Mirror mirror=new Mirror();
public Makeup() {
}
public Makeup(int flag, String girlName) {
this.flag = flag;
this.girlName = girlName;
}
public int getFlag() {
return flag;
}
public void setFlag(int flag) {
this.flag = flag;
}
public String getGirlName() {
return girlName;
}
public void setGirlName(String girlName) {
this.girlName = girlName;
}
//开始化妆
public void doMakeup() {
if (flag == 0) {
synchronized (lipstick) {
System.out.println(this.girlName + "拿着口红");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (mirror) {
System.out.println(this.girlName + "拿着镜子");
}
}
}else {
synchronized (mirror){
System.out.println(this.girlName+" 拿着镜子");
try{
Thread.sleep(2000);
}catch (Exception e){
e.printStackTrace();
}
synchronized (lipstick){
System.out.println(this.girlName+" 拿着口红");
}
}
}
}
@Override
public void run() {
this.doMakeup();
}
}
public class DeadLockThread {
public static void main(String[] args) {
new Makeup(0,"小丫").start();
new Makeup(1,"大丫").start();
}
}
线程并发协作
生产者消费者模式介绍
生产者:负责生产数据的模块(模块可能是方法、对象、线程和进程)
消费者:负责处理数据的模块(模块可能是方法、对象、线程和进程)
缓冲区:消费者不能直接使用生产者的数据,它们之间有个缓冲区。生产者将生产好的数据放入“缓冲区”,消费者从“缓冲区”拿要处理的数据
缓冲区是实现并发的核心,缓冲区的设置有两个好处:
- 实现线程的并发协作
有了缓冲区以后,生产者线程只需要往缓冲区里面放置数据,不需要管消费者消费的情况;消费者只需要从缓冲区拿出数据处理即可,也不需要管生产者生产的情况。从逻辑上实现了“生产者线程”和“消费者线程”的分离,解除了生产者与消费者之间的耦合。 - 解决忙闲不均,提高效率
生产者生产数据慢时,缓冲区仍有数据,不影响消费者消费;消费者处理数据慢时,生产者仍然可以继续往缓冲区里面放置数据。
创建缓冲区
package com.itbaizhan.Thread;
//定义馒头类
class ManTou{
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public ManTou() {
}
public ManTou(int id) {
this.id = id;
}
}
//定义缓冲区类
class SyncStack{
//定义存放馒头的盒子
private ManTou[] mt=new ManTou[10];
//定义操作盒子的索引
private int index;
//放馒头
public synchronized void push(ManTou manTou){
//判断盒子是否已满
while (this.index==this.mt.length){
try {
/**
* 语法:wait(),该方法必须要在synchronized块中调用
* wait()执行后,线程会将持有的对象锁释放,并进入阻塞状态
* 其他需要该对象锁的线程就可以继续运行了
*/
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒取馒头的线程
/**
* 该方法必须要在synchronized块中调用
* 该方法会唤醒处于等待状态队列中的一个线程
*/
this.notify();
this.mt[this.index]=manTou;
this.index++;
}
//取馒头
public synchronized ManTou pop(){
while (this.index==0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
this.index--;
return this.mt[this.index];
}
}
public class TestProduceThread {
}
创建生产者与消费者线程
package com.itbaizhan.Thread;
//定义馒头类
class ManTou{
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public ManTou() {
}
public ManTou(int id) {
this.id = id;
}
}
//定义缓冲区类
class SyncStack{
//定义存放馒头的盒子
private ManTou[] mt=new ManTou[10];
//定义操作盒子的索引
private int index;
//放馒头
public synchronized void push(ManTou manTou){
//判断盒子是否已满
while (this.index==this.mt.length){
try {
/**
* 语法:wait(),该方法必须要在synchronized块中调用
* wait()执行后,线程会将持有的对象锁释放,并进入阻塞状态
* 其他需要该对象锁的线程就可以继续运行了
*/
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//唤醒取馒头的线程
/**
* 该方法必须要在synchronized块中调用
* 该方法会唤醒处于等待状态队列中的一个线程
*/
this.notify();
this.mt[this.index]=manTou;
this.index++;
}
//取馒头
public synchronized ManTou pop(){
while (this.index==0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
this.index--;
return this.mt[this.index];
}
}
//定义生产者线程类
class Produce extends Thread{
private SyncStack ss;
public Produce(SyncStack ss) {
this.ss = ss;
}
public Produce() {
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("生产馒头:"+i);
ManTou manTou=new ManTou(i);
this.ss.push(manTou);
}
}
}
//定义消费者线程类
class consumer extends Thread{
private SyncStack ss;
public consumer() {
}
public consumer(SyncStack ss) {
this.ss = ss;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
ManTou manTou=new ManTou(i);
System.out.println("消费馒头:"+i);
}
}
}
public class TestProduceThread {
public static void main(String[] args) {
SyncStack ss=new SyncStack();
new Produce(ss).start();
new consumer(ss).start();
}
}
线程并发总结
线程并发协作(也叫线程通信)
生产者和消费者模式:
- 生产者和消费者共享同一个资源,并且生产者和消费者之间互相依赖,互为条件。
- 对于生产者,没有生产产品之前,消费者要进入等待状态,而生产了产品之后,需要马上通知消费者消费。
- 对于消费者,在消费之后,要通知生产者已经消费结束,需要继续生产新产品以供消费。
- 在生产者消费者问题中,仅有synchronized是不够的。synchronized可阻止并发更新同一个共享资源,实现了同步但是synchronized不能用来实现不同线程之间的消息传递(通信)。
- 线程可通过以下方法来进行消息传递,均是java.lang.Object类的方法,都只能在同步方法或者同步代码块中使用,否则会抛出异常
方法名 | 作用 |
---|---|
final void wait() | 表示线程一直等待,直到得到其他线程通知 |
void wait(long timeout) | 线程等待指定毫秒参数的时间 |
final void wait(long timeout,int nanos) | 线程指定毫秒、微秒的时间 |
final void notify() | 唤醒一个处于等待状态的线程 |
final void notifyAll() | 唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先运行 |