01_04_java 多线程原理

已于 2022-02-18 16:58:40 修改
阅读量79 收藏
点赞数
分类专栏： 笔记 01拉钩第一阶段javaSE 文章标签： java 多线程
于 2020-12-29 17:13:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41596178/article/details/111858628
版权

前言

文章内容输出来源：拉勾教育Java就业训练营

java IO流

多线程

基本概念

程序和进程的概念

  • 程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。
  • 进程 - 主要指运行在内存中的可执行文件。
  • 目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限。

线程的概念

  • 为了解决上述问题就提出线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程的系统资源，因此目前主流的开发都是采用多线程。
  • 多线程是采用时间片轮转法来保证多个线程的并发执行，所谓并发就是指宏观并行微观串行的机制。

线程的创建

Thread类的概念
  • java.lang.Thread类代表线程，任何线程对象都是Thread类（子类）的实例。
  • Thread类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性。
创建方式
  • 自定义类继承Thread类并重写run方法，然后创建该类的对象调用start方法。
  • 自定义类实现Runnable接口并重写run方法，创建该类的对象作为实参来构造Thread类型的对象，然后使用Thread类型的对象调用start方法。
相关的方法
方法声明功能介绍
Thread()使用无参的方式构造对象
Thread(String name)根据参数指定的名称来构造对象
Thread(Runnable target)根据参数指定的引用来构造对象，其中Runnable是个接口类型
Thread(Runnable target, String name)根据参数指定引用和名称来构造对象
void run()若使用Runnable引用构造了线程对象，调用该方法时最终调用接口中的版本若没有使用Runnable引用构造线程对象，调用该方法时则啥也不做
void start()用于启动线程，Java虚拟机会自动调用该线程的run方法

测试类ThreadTest

 public static void main(String[] args) {
        // 1.使用无参方式构造Thread类型的对象
        // 由源码可知：Thread类中的成员变量target的数值为null。
        Thread t1 = new Thread();
        // 2.调用run方法进行测试
        // 由源码可知：由于成员变量target的数值为null，因此条件if (target != null)不成立，跳过{}中的代码不执行
        //  而run方法中除了上述代码再无代码，因此证明run方法确实啥也不干
        t1.run();
        // 3.打印一句话
        System.out.println("我想看看你到底是否真的啥也不干！");
    }
输出结果>>>
我想看看你到底是否真的啥也不干！
执行流程
  • 执行main方法的线程叫做主线程，执行run方法的线程叫做新线程/子线程。
  • main方法是程序的入口，对于start方法之前的代码来说，由主线程执行一次，当start方法调用成功后线程的个数由1个变成了2个，新启动的线程去执行run方法的代码，主线程继续向下执行，两个线程各自独立运行互不影响。
  • 当run方法执行完毕后子线程结束，当main方法执行完毕后主线程结束。
  • 两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定。
方式的比较
  • 继承Thread类的方式代码简单，但是若该类继承Thread类后则无法继承其它类，而实现Runnable接口的方式代码复杂，但不影响该类继承其它类以及实现其它接口，因此以后的开发中推荐使用第二种方式。

1.线程创建和启动的方式一：
继承Thread类的子类SubThreadRun

public class SubThreadRun extends Thread {

    @Override
    public void run() {
        // 打印1 ~ 20之间的所有整数
        for (int i = 1; i <= 20; i++) {
            System.out.println("run方法中：i = " + i); // 1 2 ... 20
        }
    }
}

测试类SubThreadRunTest

public class SubThreadRunTest {

    public static void main(String[] args) {

        // 1.声明Thread类型的引用指向子类类型的对象
        Thread t1 = new SubThreadRun();
        // 2.调用run方法测试，本质上就是相当于对普通成员方法的调用，因此执行流程就是run方法的代码执行完毕后才能继续向下执行
        //t1.run();
        // 用于启动线程，Java虚拟机会自动调用该线程类中的run方法
        // 相当于又启动了一个线程，加上执行main方法的线程是两个线程
        t1.start();

        // 打印1 ~ 10之间的所有整数
        for (int i = 1; i <= 10; i++) {
            System.out.println("-----------------main方法中：i = " + i); // 1 2 ... 10
        }
    }
}

输出结果>>>
-----------------main方法中：i = 1
run方法中：i = 1
-----------------main方法中：i = 2
run方法中：i = 2
-----------------main方法中：i = 3
run方法中：i = 3
-----------------main方法中：i = 4
run方法中：i = 4
-----------------main方法中：i = 5
run方法中：i = 5
-----------------main方法中：i = 6
run方法中：i = 6
-----------------main方法中：i = 7
run方法中：i = 7
-----------------main方法中：i = 8
run方法中：i = 8
run方法中：i = 9
-----------------main方法中：i = 9
run方法中：i = 10
-----------------main方法中：i = 10

2.线程创建和启动的方式二：

继承Runnable的SubRunnableRun类

public class SubRunnableRun implements Runnable {
    @Override
    public void run() {
        // 打印1 ~ 10之间的所有整数
        for (int i = 1; i <= 10; i++) {
            System.out.println("run方法中：i = " + i); // 1 2 ... 10
        }
    }
}

测试类SubRunnableRunTest：

public class SubRunnableRunTest {

    public static void main(String[] args) {

        // 1.创建自定义类型的对象，也就是实现Runnable接口类的对象
        SubRunnableRun srr = new SubRunnableRun();
        // 2.使用该对象作为实参构造Thread类型的对象
        // 由源码可知：经过构造方法的调用之后，Thread类中的成员变量target的数值为srr。
        Thread t1 = new Thread(srr);
        // 3.使用Thread类型的对象调用start方法
        // 若使用Runnable引用构造了线程对象，调用该方法(run)时最终调用接口中的版本
        // 由run方法的源码可知：
        //	if (target != null) {
        //      target.run();
        //   }
        // 此时target的数值不为空这个条件成立，执行target.run()的代码，也就是srr.run()的代码
        t1.start();
        //srr.start();  Error

        // 打印1 ~ 10之间的所有整数
        for (int i = 1; i <= 10; i++) {
            System.out.println("-----------------main方法中：i = " + i); // 1 2 ... 10
        }
    }
}
输出结果>>>
run方法中：i = 1
-----------------main方法中：i = 1
run方法中：i = 2
-----------------main方法中：i = 2
run方法中：i = 3
-----------------main方法中：i = 3
run方法中：i = 4
-----------------main方法中：i = 4
run方法中：i = 5
-----------------main方法中：i = 5
run方法中：i = 6
-----------------main方法中：i = 6
run方法中：i = 7
-----------------main方法中：i = 7
run方法中：i = 8
-----------------main方法中：i = 8
run方法中：i = 9
-----------------main方法中：i = 9
run方法中：i = 10
-----------------main方法中：i = 10
匿名内部类的方式
  • 使用匿名内部类的方式来创建和启动线程。
    测试类：ThreadNoNameTest
public class ThreadNoNameTest {

    public static void main(String[] args) {

        // 匿名内部类的语法格式：父类/接口类型 引用变量名 = new 父类/接口类型() { 方法的重写 };
        // 1.使用继承加匿名内部类的方式创建并启动线程
        /*Thread t1 = new Thread() {
            @Override
            public void run() {
                System.out.println("张三说：有人吗？");
            }
        };
        t1.start();*/
        new Thread() {
            @Override
            public void run() {
                System.out.println("张三说：有人吗？");
            }
        }.start();

        // 2.使用实现接口加匿名内部类的方式创建并启动线程
        /*Runnable ra = new Runnable() {
            @Override
            public void run() {
                System.out.println("没有人。");
            }
        };
        Thread t2 = new Thread(ra);
        t2.start();*/
        /*new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("没有人。");
            }
        }).start();*/
        // Java8开始支持lambda表达式： (形参列表)->{方法体；}
        /*Runnable ra = ()-> System.out.println("没有人。");
        new Thread(ra).start();*/

        new Thread(()-> System.out.println("没有人。")).start();
    }
}
输出结果>>>
张三说：有人吗？
没有人

线程的生命周期

线程

  • 新建状态 - 使用new关键字创建之后进入的状态，此时线程并没有开始执行。
  • 就绪状态 - 调用start方法后进入的状态，此时线程还是没有开始执行。
  • 运行状态 - 使用线程调度器调用该线程后进入的状态，此时线程开始执行，当线程的时间片执行完毕后任务没有完成时回到就绪状态。
  • 消亡状态 - 当线程的任务执行完成后进入的状态，此时线程已经终止。
  • 阻塞状态 - 当线程执行的过程中发生了阻塞事件进入的状态，如：sleep方法。
  • 阻塞状态解除后进入就绪状态。

线程的编号和名称

方法声明功能介绍
long getId()获取调用对象所表示线程的编号
String getName()获取调用对象所表示线程的名称
void setName(String name)设置/修改线程的名称为参数指定的数值
static Thread currentThread()获取当前正在执行线程的引用

测试类ThreadIdNameTest,通过继承的方式

public class ThreadIdNameTest extends Thread {

    public ThreadIdNameTest(String name) {
        super(name); // 表示调用父类的构造方法
    }

    @Override
    public void run() {
        System.out.println("子线程的编号是：" + getId() + "，名称是：" + getName()); // 14  Thread-0 guanyu
        // 修改名称为"zhangfei"
        setName("zhangfei");
        System.out.println("修改后子线程的编号是：" + getId() + "，名称是：" + getName()); // 14  zhangfei
    }

    public static void main(String[] args) {

        ThreadIdNameTest tint = new ThreadIdNameTest("guanyu");
        tint.start();

        // 获取当前正在执行线程的引用，当前正在执行的线程是主线程，也就是获取主线程的引用
        Thread t1 = Thread.currentThread();
        System.out.println("主线程的编号是：" + t1.getId() + ", 名称是：" + t1.getName());
    }
}
输出结果>>>
主线程的编号是：1, 名称是：main
子线程的编号是：22，名称是：guanyu
修改后子线程的编号是：22，名称是：zhangfei

测试类ThreadIdNameTest,通过实现接口的方式

public class RunnableIdNameTest implements Runnable {
    @Override
    public void run() {
        // 获取当前正在执行线程的引用，也就是子线程的引用
        Thread t1 = Thread.currentThread();
        System.out.println("子线程的编号是：" + t1.getId() + "， 名称是：" + t1.getName()); // 14 guanyu
        t1.setName("zhangfei");
        System.out.println("修改后子线程的编号是：" + t1.getId() + "， 名称是：" + t1.getName()); // 14 zhangfei
    }

    public static void main(String[] args) {

        RunnableIdNameTest rint = new RunnableIdNameTest();
        //Thread t2 = new Thread(rint);
        Thread t2 = new Thread(rint, "guanyu");
        t2.start();

        // 获取当前正在执行线程的引用，当前正在执行的线程是主线程，也就是获取主线程的引用
        Thread t1 = Thread.currentThread();
        System.out.println("主线程的编号是：" + t1.getId() + ", 名称是：" + t1.getName());
    }
}
输出结果>>>
主线程的编号是：1, 名称是：main
子线程的编号是：22， 名称是：guanyu
修改后子线程的编号是：22， 名称是：zhangfei

常用的方法

方法声明功能介绍
static void yield()当前线程让出处理器（离开Running状态），使当前线程进入Runnable状态等待
static void sleep(times)使当前线程从 Running 放弃处理器进入Block状态, 休眠times毫秒, 再返回到Runnable如果其他线程打断当前线程的Block(sleep), 就会发生InterruptedException。
int getPriority()获取线程的优先级
void setPriority(int newPriority)修改线程的优先级。优先级越高的线程不一定先执行，但该线程获取到时间片的机会会更多一些
void join()等待该线程终止
void join(long millis)等待参数指定的毫秒数
boolean isDaemon()用于判断是否为守护线程
void setDaemon(boolean on)用于设置线程为守护线程

1.sleep方法的使用，测试类ThreadSleepTest

public class ThreadSleepTest extends Thread {
    // 声明一个布尔类型的变量作为循环是否执行的条件
    private boolean flag = true;

    // 子类中重写的方法不能抛出更大的异常
    @Override
    public void run() {
        // 每隔一秒获取一次系统时间并打印，模拟时钟的效果
        while (flag) {
            // 获取当前系统时间并调整格式打印
//            LocalDateTime.now();
            Date d1 = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(sdf.format(d1));

            // 睡眠1秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        ThreadSleepTest tst = new ThreadSleepTest();
        tst.start();

        // 主线程等待5秒后结束子线程
        System.out.println("主线程开始等待...");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 停止子线程  过时  不建议使用
        //tst.stop();
        tst.flag = false;
        System.out.println("主线程等待结束！");
    }
}

2.测试线程的优先级,ThreadPriorityTest

public class ThreadPriorityTest extends Thread {
    @Override
    public void run() {
        //System.out.println("子线程的优先级是：" + getPriority()); // 5  10  优先级越高的线程不一定先执行。
        for (int i = 0; i < 20; i++) {
            System.out.println("子线程中：i = " + i);
        }
    }

    public static void main(String[] args) {

        ThreadPriorityTest tpt = new ThreadPriorityTest();
        // 设置子线程的优先级
        tpt.setPriority(Thread.MAX_PRIORITY);
        tpt.start();

        Thread t1 = Thread.currentThread();
        //System.out.println("主线程的优先级是：" + t1.getPriority()); // 5 普通的优先级
        for (int i = 0; i < 20; i++) {
            System.out.println("--主线程中：i = " + i);
        }
    }

}
结果>>>
修改线程的优先级。优先级越高的线程不一定先执行，但该线程获取到时间片的机会会更多一些

3.测试Thread的常用方法join，ThreadJoinTest类

public class ThreadJoinTest extends Thread {
    @Override
    public void run() {
        // 模拟倒数10个数的效果
        System.out.println("倒计时开始...");
        for (int i = 10; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("新年快乐！");
    }

    public static void main(String[] args) {

        ThreadJoinTest tjt = new ThreadJoinTest();
        tjt.start();

        // 主线程开始等待
        System.out.println("主线程开始等待...");
        try {
            // 表示当前正在执行的线程对象等待调用线程对象，也就是主线程等待子线程终止
            //tjt.join();
            tjt.join(5000); // 最多等待5秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //System.out.println("终于等到你，还好没放弃！");
        System.out.println("可惜不是你，陪我到最后！");
    }
}

4.测试守护线程，

public class ThreadDaemonTest extends Thread {
    @Override
    public void run() {
        //System.out.println(isDaemon()? "该线程是守护线程": "该线程不是守护线程"); // 默认不是守护线程
        // 当子线程不是守护线程时，虽然主线程先结束了，但是子线程依然会继续执行，直到打印完毕所有数据为止
        // 当子线程是守护线程时，当主线程结束后，则子线程随之结束
        for (int i = 0; i < 50; i++) {
            System.out.println("子线程中：i = " + i);
        }
    }

    public static void main(String[] args) {

        ThreadDaemonTest tdt = new ThreadDaemonTest();
        // 必须在线程启动之前设置子线程为守护线程
        tdt.setDaemon(true);
        tdt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("-------主线程中：i = " + i);
        }
    }
}
输出结果>>>
虽然主线程结束后子线程也会结束但是结束后，还是会运行一部分的值。
  • 编程创建两个线程，线程一负责打印1 ~ 100之间的所有奇数，其中线程二负责打印1 ~ 100之间的所有偶数。
    在main方法启动上述两个线程同时执行,主线程等待两个线程终止。
    打印奇数的类
public class SubThread1 extends Thread {
//public class SubThread1 implements Runnable {
    @Override
    public void run() {
        // 打印1 ~ 100之间的所有奇数
        for (int i = 1; i <= 100; i += 2) {
            System.out.println("子线程一中： i = " + i);
        }
    }
}

打印偶数的类

public class SubThread2 extends Thread {
//public class SubThread2 implements Runnable{
    @Override
    public void run() {
        // 打印1 ~ 100之间的所有偶数
        for (int i = 2; i <= 100; i += 2) {
            System.out.println("------子线程二中： i = " + i);
        }
    }
}

测试类SubThreadTest

public class SubThreadTest {

    public static void main(String[] args) {
		
        SubThread1 st1 = new SubThread1();
        SubThread2 st2 = new SubThread2();
		
		//当使用Runnable接口时使用
		//SubThread1 s1 = new SubThread1();
        //SubThread2 s2 = new SubThread2();
		
		//Thread st1 = new Thread(s1);
        //Thread st2 = new Thread(s2);

        st1.start();
        st2.start();

        System.out.println("主线程开始等待...");
        try {
            st1.join();
            st2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程等待结束！");
    }
}

线程同步机制

基本概念
  • 当多个线程同时访问同一种共享资源时，可能会造成数据的覆盖等不一致性问题，此时就需要对线程之间进行通信和协调，该机制就叫做线程的同步机制。
  • 多个线程并发读写同一个临界资源时会发生线程并发安全问题。
  • 异步操作:多线程并发的操作，各自独立运行。
  • 同步操作:多线程串行的操作，先后执行的顺序。
解决方案
  • 由程序结果可知：当两个线程同时对同一个账户进行取款时，导致最终的账户余额不合理。
  • 引发原因：线程一执行取款时还没来得及将取款后的余额写入后台，线程二就已经开始取款。
  • 解决方案：让线程一执行完毕取款操作后，再让线程二执行即可，将线程的并发操作改为串行操
    作。
  • 经验分享：在以后的开发尽量减少串行操作的范围，从而提高效率。
实现方式
  • 在Java语言中使用synchronized关键字来实现同步/对象锁机制从而保证线程执行的原子性，具体方式如下：
  • 使用同步代码块的方式实现部分代码的锁定，格式如下：
    synchronized(类类型的引用) {
    编写所有需要锁定的代码；
    }
  • 使用同步方法的方式实现所有代码的锁定。
    直接使用synchronized关键字来修饰整个方法即可
    该方式等价于:
    synchronized(this) { 整个方法体的代码 }

测试实现接口为Runnable时，实现线程同步

public class AccountRunnableTest implements Runnable {
    private int balance; // 用于描述账户的余额
    private Demo dm = new Demo();

    public AccountRunnableTest() {
    }

    public AccountRunnableTest(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public /*synchronized*/ void run() {
        // 由源码可知：最终是account对象来调用run方法，因此当前正在调用的对象就是account，也就是说this就是account
        synchronized (this) { // ok
        System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
        //synchronized (dm) { // ok
        //synchronized (new Demo()) { // 锁不住  要求必须是同一个对象
            // 1.模拟从后台查询账户余额的过程
            int temp = getBalance(); // temp = 1000  temp = 1000
            // 2.模拟取款200元的过程
            if (temp >= 200) {
                System.out.println("正在出钞，请稍后...");
                temp -= 200;  // temp = 800   temp = 800
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            } else {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            // 3.模拟将最新的账户余额写入到后台
            setBalance(temp); // balance = 800  balance = 800
        }
       
    }

    public static void main(String[] args) {

        AccountRunnableTest account = new AccountRunnableTest(1000);
        //AccountRunnableTest account2 = new AccountRunnableTest(1000);
        Thread t1 = new Thread(account);
        Thread t2 = new Thread(account);
        //Thread t2 = new Thread(account2);
        t1.start();
        t2.start();

        System.out.println("主线程开始等待...");
        try {
            t1.join();
            //t2.start(); // 也就是等待线程一取款操作结束后再启动线程二
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("最终的账户余额为：" + account.getBalance()); // 600  800
    }
}

class Demo{}

输出结果>>>
主线程开始等待...
线程Thread-0已启动...
正在出钞，请稍后...
请取走您的钞票！
线程Thread-1已启动...
正在出钞，请稍后...
请取走您的钞票！
最终的账户余额为：600
静态方法的锁定
  • 当我们对一个静态方法加锁，如:
    public synchronized static void xxx(){….}
  • 那么该方法锁的对象是类对象。每个类都有唯一的一个类对象。获取类对象的方式:类名.class。
  • 静态方法与非静态方法同时使用了synchronized后它们之间是非互斥关系的。
  • 原因在于：静态方法锁的是类对象而非静态方法锁的是当前方法所属对象。

测试当继承Thread时，实现静态方法线程同步

public class AccountThreadTest extends Thread {
    private int balance; // 用于描述账户的余额
    private static Demo dm = new Demo(); // 隶属于类层级，所有对象共享同一个

    public AccountThreadTest() {
    }

    public AccountThreadTest(int balance) {
        this.balance = balance;
    }

    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }

    @Override
    public /*static*/ /*synchronized*/ void run() {
        /*System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
        //synchronized (dm) { // ok
            //synchronized (new Demo()) { // 锁不住  要求必须是同一个对象
            // 1.模拟从后台查询账户余额的过程
            int temp = getBalance(); // temp = 1000  temp = 1000
            // 2.模拟取款200元的过程
            if (temp >= 200) {
                System.out.println("正在出钞，请稍后...");
                temp -= 200;  // temp = 800   temp = 800
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            } else {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            // 3.模拟将最新的账户余额写入到后台
            setBalance(temp); // balance = 800  balance = 800
        //}*/
        test();
    }

    public /*synchronized*/ static void test() {
        synchronized (AccountThreadTest.class) { // 该类型对应的Class对象，由于类型是固定的，因此Class对象也是唯一的，因此可以实现同步
            System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
            //synchronized (dm) { // ok
            //synchronized (new Demo()) { // 锁不住  要求必须是同一个对象
            // 1.模拟从后台查询账户余额的过程
            int temp = 1000; //getBalance(); // temp = 1000  temp = 1000
            // 2.模拟取款200元的过程
            if (temp >= 200) {
                System.out.println("正在出钞，请稍后...");
                temp -= 200;  // temp = 800   temp = 800
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            } else {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            // 3.模拟将最新的账户余额写入到后台
            //setBalance(temp); // balance = 800  balance = 800
        }
    }

    public static void main(String[] args) {

        AccountThreadTest att1 = new AccountThreadTest(1000);
        att1.start();

        AccountThreadTest att2 = new AccountThreadTest(1000);
        att2.start();

        System.out.println("主线程开始等待...");
        try {
            att1.join();
            //t2.start(); // 也就是等待线程一取款操作结束后再启动线程二
            att2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("最终的账户余额为：" + att1.getBalance()); // 800

    }

}
注意事项
  • 使用synchronized保证线程同步应当注意:
    1.多个需要同步的线程在访问同步块时，看到的应该是同一个锁对象引用。
    2.在使用同步块时应当尽量减少同步范围以提高并发的执行效率。
线程安全类和不安全类
  • StringBuffer类是线程安全的类，但StringBuilder类不是线程安全的类。
  • Vector类和 Hashtable类是线程安全的类，但ArrayList类和HashMap类不是线程安全的类。
  • Collections.synchronizedList() 和 Collections.synchronizedMap()等方法实现安全。
死锁的概念
  • 线程一执行的代码：
public void run(){
 synchronized(a){ //持有对象锁a，等待对象锁b
 	synchronized(b){
 	编写锁定的代码;
 	}
 }
}
  • 线程二执行的代码：
public void run(){
 synchronized(b){ //持有对象锁b，等待对象锁a
 	synchronized(a){
 	编写锁定的代码;
 	}
 }
}
  • 注意：在以后的开发中尽量减少同步的资源，减少同步代码块的嵌套结构的使用！
使用Lock（锁）实现线程同步
基本概念
  • 从Java5开始提供了更强大的线程同步机制—使用显式定义的同步锁对象来实现。
  • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
  • 该接口的主要实现类是ReentrantLock类，该类拥有与synchronized相同的并发性，在以后的线程安全控制中，经常使用ReentrantLock类显式加锁和释放锁。
常用的方法
方法声明功能介绍
ReentrantLock()使用无参方式构造对象
void lock()获取锁
void unlock()释放锁

测试locks类的AccountRunnableTest

private ReentrantLock lock = new ReentrantLock();  // 准备了一把锁，新增

   @Override
    public /*synchronized*/ void run() {
        // 开始加锁，新增
        lock.lock();

        // 由源码可知：最终是account对象来调用run方法，因此当前正在调用的对象就是account，也就是说this就是account
        //synchronized (this) { // ok
        System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
        //synchronized (dm) { // ok
        //synchronized (new Demo()) { // 锁不住  要求必须是同一个对象
            // 1.模拟从后台查询账户余额的过程
            int temp = getBalance(); // temp = 1000  temp = 1000
            // 2.模拟取款200元的过程
            if (temp >= 200) {
                System.out.println("正在出钞，请稍后...");
                temp -= 200;  // temp = 800   temp = 800
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("请取走您的钞票！");
            } else {
                System.out.println("余额不足，请核对您的账户余额！");
            }
            // 3.模拟将最新的账户余额写入到后台
            setBalance(temp); // balance = 800  balance = 800
        //}
        lock.unlock(); // 实现解锁，新增
    }
与synchronized方式的比较
  • Lock是显式锁，需要手动实现开启和关闭操作，而synchronized是隐式锁，执行锁定代码后自动释放。
  • Lock只有同步代码块方式的锁，而synchronized有同步代码块方式和同步方法两种锁。
  • 使用Lock锁方式时，Java虚拟机将花费较少的时间来调度线程，因此性能更好。
Object类常用的方法
方法声明功能介绍
void wait()用于使得线程进入等待状态，直到其它线程调用notify()或notifyAll()方 法
void wait(long timeout)用于进入等待状态，直到其它线程调用方法或参数指定的毫秒数已经过去为止
void notify()用于唤醒等待的单个线程
void notifyAll()用于唤醒等待的所有线程

测试类ThreadCommunicateTest执行过程为，线程1执行完成后执行线程2。

public class ThreadCommunicateTest implements Runnable {
    private int cnt = 1;

    @Override
    public void run() {
        while (true) {
            synchronized (this) {
                // 每当有一个线程进来后先大喊一声，调用notify方法
                notify();
                if (cnt <= 100) {
                    System.out.println("线程" + Thread.currentThread().getName() + "中：cnt = " + cnt);
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    cnt++;
                    // 当前线程打印完毕一个整数后，为了防止继续打印下一个数据，则调用wait方法
                    try {
                        wait(); // 当前线程进入阻塞状态，自动释放对象锁，必须在锁定的代码中调用
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    break;
                }
            }
        }
    }

    public static void main(String[] args) {

        ThreadCommunicateTest tct = new ThreadCommunicateTest();
        Thread t1 = new Thread(tct);
        t1.start();

        Thread t2 = new Thread(tct);
        t2.start();
    }
}
生产者消费者模型
  • 概念
    生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。
    在这里插入图片描述
    仓库类
/**
 * 编程实现仓库类
 */
public class StoreHouse {
    private int cnt = 0; // 用于记录产品的数量

    public synchronized void produceProduct() {
        notify();
        if (cnt < 10) {
            System.out.println("线程" + Thread.currentThread().getName() + "正在生产第" + (cnt+1) + "个产品...");
            cnt++;
        } else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void consumerProduct() {
        notify();
        if (cnt > 0) {
            System.out.println("线程" + Thread.currentThread().getName() + "消费第" + cnt + "个产品");
            cnt--;
        } else {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

生产者

/**
 * 编程实现生产者线程，不断地生产产品
 */
public class ProduceThread extends Thread {
    // 声明一个仓库类型的引用作为成员变量，是为了能调用调用仓库类中的生产方法   合成复用原则
    private StoreHouse storeHouse;
    // 为了确保两个线程共用同一个仓库
    public ProduceThread(StoreHouse storeHouse) {
        this.storeHouse = storeHouse;
    }

    @Override
    public void run() {
        while (true) {
            storeHouse.produceProduct();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

消费者

/**
 * 消费者线程
 */
public class ConsumerThread extends Thread {
    // 声明一个仓库类型的引用作为成员变量，是为了能调用调用仓库类中的生产方法   合成复用原则
    private StoreHouse storeHouse;
    // 为了确保两个线程共用同一个仓库
    public ConsumerThread(StoreHouse storeHouse) {
        this.storeHouse = storeHouse;
    }

    @Override
    public void run() {
        while (true) {
            storeHouse.consumerProduct();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试类

public class StoreHouseTest {

    public static void main(String[] args) {

        // 创建仓库类的对象
        StoreHouse storeHouse = new StoreHouse();
        // 创建线程类对象并启动
        ProduceThread t1 = new ProduceThread(storeHouse);
        ConsumerThread t2 = new ConsumerThread(storeHouse);
        t1.start();
        t2.start();
    }
}
输出>>>
线程Thread-1消费1个产品
线程Thread-0正在生产1个产品...
线程Thread-1消费1个产品
线程Thread-0正在生产1个产品...
......
线程池
实现Callable接口
  • 从Java5开始新增加创建线程的第三种方式为实java.util.concurrent.Callable接口。
  • 常用的方法如下：
方法声明功能介绍
V call()计算结果并返回
FutureTask类
  • java.util.concurrent.FutureTask类用于描述可取消的异步计算，该类提供了Future接口的基本实现，包括启动和取消计算、查询计算是否完成以及检索计算结果的方法，也可以用于获取方法调用后的返回结果。
  • 常用的方法如下：
方法声明功能介绍
FutureTask(Callable callable)根据参数指定的引用来创建一个未来任务
V get()获取call方法计算的结果

测试类

public class ThreadCallableTest implements Callable {

    @Override
    public Object call() throws Exception {
        // 计算1 ~ 10000之间的累加和并打印返回
        int sum = 0;
        for (int i = 1; i <= 10000; i++) {
            sum +=i;
        }
        System.out.println("计算的累加和是：" + sum); // 50005000
        return sum;
    }

    public static void main(String[] args) {

        ThreadCallableTest tct = new ThreadCallableTest();
        FutureTask ft = new FutureTask(tct);
        Thread t1 = new Thread(ft);
        t1.start();
        Object obj = null;
        try {
            obj = ft.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("线程处理方法的返回值是：" + obj); // 50005000
    }
}
输出结果>>>
计算的累加和是：50005000
线程处理方法的返回值是：50005000
线程池的由来
  • 在服务器编程模型的原理，每一个客户端连接用一个单独的线程为之服务，当与客户端的会话结束时，线程也就结束了，即每来一个客户端连接，服务器端就要创建一个新线程。
  • 如果访问服务器的客户端很多，那么服务器要不断地创建和销毁线程，这将严重影响服务器的性能。
概念和原理
  • 线程池的概念：首先创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，服务完后不关闭该线程，而是将该线程还回到线程池中。
  • 在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。
相关类和方法
  • 从Java5开始提供了线程池的相关类和接口：java.util.concurrent.Executors类和java.util.concurrent.ExecutorService接口。
  • 其中Executors是个工具类和线程池的工厂类，可以创建并返回不同类型的线程池，常用方法如下：
方法声明功能介绍
static ExecutorService newCachedThreadPool()创建一个可根据需要创建新线程的线程池
static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池
static ExecutorService newSingleThreadExecutor()创建一个只有一个线程的线程池
  • 其中ExecutorService接口是真正的线程池接口，主要实现类是ThreadPoolExecutor，常用方法如下：
方法声明功能介绍
void execute(Runnable command)执行任务和命令，通常用于执行Runnable
Future submit(Callable task)执行任务和命令，通常用于执行Callable
void shutdown()启动有序关闭

测试线程池

public class ThreadPoolTest {

    public static void main(String[] args) {

        // 1.创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        // 2.向线程池中布置任务
        executorService.submit(new ThreadCallableTest());
        // 3.关闭线程池
        executorService.shutdown();
    }
}

下一阶段，java 网络编程

广+土
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程基础的总结
weixin_43517271的博客
10-11 176
一.基本的概念 进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。（进程是资源分配的最小单位）　 线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）　　 线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。　　 多进程是指操作系统能同时运行多个任务（程序）。　　 多线程是指在同一程序中有多个顺序流在执行。 即：线程《线程（一个程序可以有多个线程） 程序：静态的代码
万字图解Java多线程
qq_35598736的博客
09-06 5万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java多线程（超详细！）
热门推荐
一只小菜鸡
05-13 12万+
1、什么是进程？什么是线程？ 进程是:一个应用程序（1个进程是一个软件）。 线程是：一个进程中的执行场景/执行单元。 注意：一个进程可以启动多个线程。 eg.对于java程序来说，当在DOS命令窗口中输入： java HelloWorld 回车之后。 会先启动JVM，而JVM就是一个进程。 JVM再启动一个主线程调用main方法。 同时再启动一个垃圾回收线程负责看护，回收垃圾。 最起码，现在的java程序中至少有两个线程并发， 一个是垃圾回收线程，一个是执行main方法的主线程。 3、进程和线程是什么关系？
java多线程（超详细）
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程--AQS的原理
IT利刃出鞘的博客
11-04 3984
本文介绍Java中的AQS的原理。 Java的AQS是JDK自带的锁机制，是JUC（java.util.concurrent）的基础，很多并发类都是基于它实现的，例如：ReentrantLock、CountDownLatch、Semaphore、ReadWriteLock，CyclicBarrier。
Java售票任务_多线程详细实现
qq_40285647的博客
06-12 2669
Java售票任务_多线程详细实现 题目回顾：铁道部发布了一个售票任务，要求销售1000张票，要求有3个窗口来进行销售，请编写多线程程序来模拟这个效果。 ​ i. 窗口001正在销售第1000张票 ​ ii. 窗口001正在销售第999张票 ​ iii. 窗口002正在销售第998张票 ​ iv. … ​ v. 窗口002正在销售第1张票 ​ vi. 票已经销售完毕 一 、注意细节： ​ 问题1：三个线程都卖了1000张票，一共卖了3000张票 ​ 原因：三个线程代表三个对象，就有三个成
Java多线程--ThreadLocal的原理
IT利刃出鞘的博客
11-10 1647
原文网址 简介 说明 ThreadLocal简介 ThreadLocal 的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者组件之间一些公共变量的传递的复杂度。 ...
Java多线程(四)线程锁
yuanchun的知识整理
11-03 4540
Java多线程(四)线程锁
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5376
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java多线程并发编程技术详解
最新发布
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
03-20 1万+
Java多线程并发编程是一项需要深入理解和熟练掌握的技术，只有合理地设计和使用多线程，才能真正发挥其在提升系统性能方面的巨大潜力。随着对Java并发机制及工具类库的深入学习和应用，开发者可以更好地构建高效、稳定的并发系统。
Java多线程编程核心技术_完整版_java_
09-30
详细介绍了java多线程的原理以及常用多线程编程方法及注意事项。
Java多线程编程总结
01-31
要认识多线程就要从操作系统的原理说起。以前古老的DOS操作系统（V6.22）是单任务的，还没有线程的概念，系统在每次只能做一件事情。比如你在copy东西的时候不能rename文件名。为了提高系统的利用效率，采用批处理来...
详解java多线程的同步控制
01-20
同步控制是并发程序必不可少的重要手段，本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
Java多线程锁机制相关原理实例解析
08-18
主要介绍了Java多线程锁机制相关原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java多线程start（）方法原理解析
08-25
主要介绍了Java多线程start（）方法原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
01_03_java基础 java类库的使用(上)
weixin_41596178的博客
12-11 464
类库的使用 常用的类 包的名称和功能 java.lang包 - 该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入。如：System类、String类、… java.util包 - 该包是Java语言的工具包，里面提供了大量工具类以及集合类等。如：Scanner类、Random类、List集合、… java.io包 - 该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等。如：FileInputStream类、FileOutputStream类、… java.net包
05_02_ Vue基础入门（axios，computed计算属性、filter过滤器、watch侦听器、vue生命周期、组件、路由）
weixin_41596178的博客
12-31 399
Vue.js 1.Vue.js 1.1 Vue.js 介绍 1.1.1 Vue.js是什么? Vue (读音 /vjuː/，类似于 view) 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是， Vue 被设计 为可以自底向上逐层应用. Vue 的核心库只关注视图层，不仅易于上手，还便于与第三方库或既有项目整合。另一 方面，当与 现代化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。 自底向上逐层应用：作为渐进式框架要实现的目标就是方便项目增量开发(即插即用)。
05_01_拉钩教育课程管理系统之一：项目介绍
weixin_41596178的博客
12-08 394
任务一 项目介绍与后台系统搭建 1. 项目架构 1.1 项目介绍 ​ 拉钩教育后台管理系统,是提供给拉钩教育的相关业务人员使用的一个后台管理系统, 业务人员可以在这个后台管理系统中,对课程信息、讲师信息、 学员信息等数据进行维护. ​ 为了巩固 web阶段的技术的理解,提高综合运用技术的能力, 接下来会去完成拉钩教育后台管理系统中的课程管理模块. 1.2 模块介绍 打开产品需求文档,我们一起去看一下课程管理模块中都包含哪些内容: 课程信息页面展示 课程营销信息配置 配置课时( 即课程内容管理) 1.3
02_01_MySQL的单表&约束&事务
weixin_41596178的博客
02-08 389
前言 文章内容输出来源：拉勾教育Java就业训练营 上个阶段 进入数据库阶段 学习MySQL阶段 mysql基础与sql语句 DQL操作单表 创建数据库,复制表
java多线程的底层原理
02-27
Java多线程的底层原理主要涉及到线程的创建、调度和同步等方面。 1. 线程的创建：Java中创建线程的方式有两种，一种是继承Thread类，另一种是实现Runnable接口。当创建一个线程时，操作系统会为其分配一个唯一的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值