多线程技术

欣欣向蓉学Java

于 2024-08-06 23:52:47 发布

阅读量1k

点赞数 33

文章标签： java

本文链接：https://blog.csdn.net/m0_73852099/article/details/140759505

版权

多线程介绍

多线程中的基本概念

程序(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()方法的线程，优先级别高的线程优先运行

欣欣向蓉学Java

关注

33
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
多线程技术

并发是指在一段时间内同时做多个事情。当多个线程在运行时，如果只有一个CPU，这种情况下计算机操作系统会采用并发技术实现并发运行，具体作废是采用“时间片轮循算法”，在一个时间段的线程代码运行时，其他代码处于就绪状。这种方式称之为并发。串行（serial）:一个CPU上，按顺序完成多个任务并行（parallelism）:指的是任务数小于等于CPU核数，即任务真的是一起执行的。并发（concurrency）:一个CPU采用时间片管理方式交替的处理多个任务。
复制链接

扫一扫