Java学习笔记（尚硅谷，多线程）

最新推荐文章于 2023-05-04 20:36:00 发布
最新推荐文章于 2023-05-04 20:36:00 发布
阅读量258 收藏 2
点赞数 1
分类专栏： Java 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52354687/article/details/117475535
版权

程序&进程&线程

  • 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

  • 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
    如：运行中的QQ，运行中的MP3播放器
    程序是静态的，进程是动态的
    进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

  • 线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。
    若一个进程同一时间并行执行多个线程，就是支持多线程的，线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小
    一个进程中的多个线程共享相同的内存单元/内存地址空间
    它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

多线程创建的两种方法

一、创建Thread类的子类对象

  1. 创建一个继承于 Thread 类的子类
  2. 重写 Thread 类的 run()
  3. 创建 Thread 类的子类的对象
  4. 通过此对象调用 start()

注意：
直接调用 run() 方法不是多线程
一个已经 start() 的线程不能再启动一个 start()

public class OtherTest {
    public static void main(String[] args) {
        MyThread myThread = new MyThread("分线程");
        myThread.start();

        Thread.currentThread().setName("主线程");
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":\t" + Thread.currentThread().getPriority() + ":\t" + i);
            }
        }
    }
}

class MyThread extends Thread {
    public MyThread() {
    }

    public MyThread(String name) {
        super(name);
    }

    public void run() {
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":\t" + Thread.currentThread().getPriority() + ":\t" + i);
            }
        }
    }
}

二、实现Runnable接口

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable的抽象方法：run()
  3. 创建实现类的对象
  4. 将实现类的对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start()：①启动线程②调用当前线程的run()–>调用的runnable类型的target的run()
public class OtherTest {
    public static void main(String[] args) {
        Windows windows = new Windows();
        Thread t1 = new Thread(windows);
        Thread t2 = new Thread(windows);
        Thread t3 = new Thread(windows);

        t1.setName("售票处1：");
        t2.setName("售票处2：");
        t3.setName("售票处3：");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Windows implements Runnable {
    // 不需要使用static修饰，因为t1，t2，t3都是用该类的同一对象创建的
    private int ticket = 100;

    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出号码为" + ticket + "的票");
                ticket--;
            } else {
                break;
            }
        }
    }
}

Thread类的常用方法

 1. start()//启动当前线程，调用当前线程的run()
 2. run()//通常需要重写Thread类的此方法，将创建的线程要执行的操作声明在此方法中
 3. currentThread()//静态方法，返回执行当前代码的线程
 4. getName()//获取当前线程的名称
 5. setName()//设置当前线程的名称
 6. Thread.currentThread().setName("主线程");//设置主线程的名称
 7. yield()//释放当前CPU的执行权，但可能CPU又会将执行权分配给当前线程
 8. join()//在线程a中调用线程b的join()，此时线程a就进入阻塞状态，只有等线程b完全执行完以后才执行线程a
 9. sleep()//让当前线程“睡眠”指定的millitime毫秒，在指定的millitime毫秒时间内，当前线程是阻塞状态
 10.isalive()//判断当前线程是否存活

线程的优先级

MAX_PRIORITY：10 //最高的优先级
MIN _PRIORITY：1 //最低的优先级
NORM_PRIORITY：5 //一般情况下的默认优先级
getPriority() ：返回线程优先值
setPriority(int newPriority) ：改变线程的优先级

线程的同步

1、同步代码块

synchronized (同步监视器（锁）) {
	// 需要被同步的代码（操作共享数据的代码）
}
// 任何对象都可以充当锁（要求：所有线程都共用同一把锁）

public class OtherTest {
    public static void main(String[] args) {
        Windows windows = new Windows();
        Thread t1 = new Thread(windows);
        Thread t2 = new Thread(windows);
        Thread t3 = new Thread(windows);

        t1.setName("售票处1：");
        t2.setName("售票处2：");
        t3.setName("售票处3：");

        t1.start();
        t2.start();
        t3.start();
    }
}

class Windows implements Runnable {
    // 不需要使用static修饰，因为t1，t2，t3都是用该类的同一对象创建的
    private int ticket = 100;
    Object o = new Object();

    @Override
    public void run() {
        while (true) {
        	// 继承方式不能使用synchronized (this)方式同步，因为他们的this不是同一个对象
        	// 若要继承方式想要使用同步代码块，则可以将同步监视器声明为static
            synchronized (o) {	//synchronized (this) // synchronized (Windows.class)
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "卖出号码为" + ticket + "的票");
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

2、同步方法

private synchronized void method(){}	// 同步监视器：this
// 继承方式，此时的同步监视器：类.class
private static synchronized void method(){}
  1. 同步方法仍然涉及到同步监视器，只是不需要显式的声明
  2. 非静态的同步方法，同步监视器是：this
  3. 静态的同步方法，同步监视器是：类.class

3、解决“懒汉式”线程不安全的问题

class Bank {
    private Bank() {}

    private static Bank bank = null;

    public static Bank getBank() {
        // 这种方式效率较高
        if (bank == null) {
            synchronized (Bank.class) {
                if (bank == null) {
                    bank = new Bank();
                }
            }
        }
        return bank;
    }
}

死锁

理解：不同的线程分别占用对方所需要的同步资源不放弃，都在等待对方放弃自己所需要的同步资源，就形成了线程的死锁

说明：

  1. 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续
  2. 我们使用同步时，要避免死锁的出现
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(new Runnable() {
   @Override
   public void run() {
       synchronized (s1) {
           s1.append('a');
           s2.append(1);
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           synchronized (s2) {
               s1.append('b');
               s2.append(2);
               System.out.println(s1);
               System.out.println(s2);
           }
       }
   }
}).start();
new Thread(new Runnable() {
   @Override
   public void run() {
       synchronized (s2) {
           s1.append('c');
           s2.append(3);
           try {
               Thread.sleep(100);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           synchronized (s1) {
               s1.append('d');
               s2.append(4);
               System.out.println(s1);
               System.out.println(s2);
           }
       }
   }
}).start();

3、Lock锁

Lock是一个接口，ReentrantLock是它的一个实现类

private ReentrantLock lock = new ReentrantLock();	// 实例化ReentrantLock

@Override
public void run() {
	try {
		lock.lock();	// 调用锁定方法lock()
		// 需要同步的代码
	} finally {
		lock.unlock();	// 调用解锁方法unlock()
	}
}

使用优先顺序：Lock、同步代码块、同步方法
同步的缺点：操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

线程的通信

wait();//让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”)
notify();//唤醒当前对象上的等待线程
notifyAll();//唤醒所有线程
  1. 以上三个方法都只能使用在同步代码块或同步方法中
  2. 以上三个方法调用者必须是同步代码块或同步方法的同步监视器
  3. 以上三个方法都定义在java.lang.Object类中
class Windows implements Runnable {
    private int num = 1;
	private Object obj = new Object();
	
    @Override
    public void run() {
        while (true) {
            synchronized (obj) {
                obj.notify();//唤醒线程
                if (num <= 100) {
                    try {
                        Thread.sleep(2);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + num);
                    num++;
                    try {
                        obj.wait();//让当前线程处于阻塞状态，释放同步锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                else {
                    break;
                }
            }
        }
    }
}

JDK5.0新增的多线程创建的两种方法

1. 实现Callable接口

1.创建一个实现Callable的实现类
2.实现call(),将此线程需要执行的操作声明在call()中
3.创建Callable接口实现类的对象
4.将此Callable接口实现类的对象作为参数传递到FutureTask类的构造器中，创建FutureTask类的对象
5.将FutureTask类的对象作为参数传递到Thread类的构造器中，创建Thread类对象，并调用start()
6.获取Callable中call()的返回值（可选）

public class ThreadNew {
    public static void main(String[] args) {
    	// 3.创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
		// 4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        // 5.将FutureTask类的对象作为参数传递到Thread类的构造器中，创建Thread类对象，并调用start()
        new Thread(futureTask).start();
		// 6.获取Callable中call()的返回值（可选）
        try {
            // get()返回值即为FutureTask构造器参数Callable实现类重写的call()返回值
            Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
// 1.创建一个实现Callable的实现类
class NumThread implements Callable {
    @Override
    // 2.实现call(),将此线程需要执行的操作声明在call()中
    public Object call() throws Exception {	// 求100以内偶数和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;// 自动转换为包装类
    }
}

2. 使用线程池

在这里插入图片描述

public class ThreadPool {
    public static void main(String[] args) {
        // 1、提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 设置线程池的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15);	// 设置核心池的大小

        // 2、执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());    // 适合用于Runnable
        service.execute(new NumberThread1());   // 适合用于Runnable
        // service.submit();    // 适合用于Callable

        // 关闭连接池
        service.shutdown();
    }
}

class NumberThread implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

class NumberThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}
ac_qyd
关注
专栏目录
尚硅谷Java入门视频教程第八章——多线程
yw_1121的博客
05-08 351
尚硅谷Java入门视频教程第八章——多线程
Java 学习多线程笔记
cyberscutoid的博客
03-07 2233
多线程的目的 为了更合理的利用cpu资源 多线程的概念 一个进程运行时产生多个线程 并行与并发 并行：多个cpu实例同时执行一段逻辑 并发：通过cpu调度算法，让程序看上去像是同时执行，提高程序运行效率。 线程安全 线程安全：在并发的前提下，该代码经过多线程的使用，线程的调度顺序不影响产生的结果。 线程不安全：与线程安全相反，线程的调度顺序影响最终的结果 同步：通过人为的控制与调度，保证共享资源的多线程访问成为线程安全，确保结果的准确。 调度：1.分时 2.抢占
13.尚硅谷_java基础_多线程
09-26
线程的概念模型 线程的创建和启动 临界资源、对象锁 线程的互斥和同步
尚硅谷_Java零基础教程（多线程）-- 学习笔记
JMW1407的博客
08-26 584
Java 多线程一、基本概念1、程序、进程、线程2、单核CPU和多核CPU、并行与并发3、使用多线程的优点二、线程的创建和使用1、API中创建线程的两种方式1.1、方式一： 继承Thread类1.2、方式二：实现Runnable接口1.3、Thread类的调用的API方法2、线程的调度3、线程的优先级三、线程的生命周期四、线程的同步1、同步方法1.1、Synchronized的使用方法五、线程的通信六、JDK5.0新增线程创建方式 一、基本概念 1、程序、进程、线程 程序(program)：是为完成特定任
JUC多线程及高并发面试题
08-23 690
JUC多线程及高并发 [TOC] 一、请你谈谈对volatile的理解 ​ Package java.util.concurrent---> AtomicInteger Lock ReadWriteLock 1、volatile是java虚拟机提供的轻量级的同步机制 保证可见性、不保证...
尚硅谷java多线程
m0_63961750的博客
05-04 248
 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。 对于类 C 的每一个 e1 和 e2 来说，当且仅当 e1.compareTo(e2) == 0 与e1.equals(e2) 具有相同的 boolean 值时， native long currentTimeMillis()：该方法的作用是返回当前的计算机时间，时间的表达格式为当前计算机时间和GMT时间(格林威治时间)
尚硅谷java学习笔记——11.java多线程
无关风月
02-18 1821
1、理解程序、进程、线程的概念 程序可以理解为静态的代码 进程可以理解为执行中的程序 线程可以理解为进程的进一步细分，程序的一条执行路径 使用多线程的优点： 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。 提高计算机系统CPU的利用率 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改 Thread的常用方法： 1、start( ):启动线程
Java基础尚硅谷宋红康学习笔记
05-29
7. **多线程**：Java内置了对多线程的支持，通过Thread类或实现Runnable接口可以创建并运行多个线程，实现并发执行。 8. **接口与内部类**：接口定义了一组方法签名，提供了一种实现多继承的方式。内部类（包括成员...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java 基础 第3阶段：高级应用-尚硅谷学习笔记（含面试题） 2023年
05-09
在这个阶段的学习中，尚硅谷提供了2023年的学习笔记和面试题，帮助你提升Java技能并为求职做好准备。 首先，多线程是Java的一个关键特性，允许程序同时执行多个任务。理解线程的创建（通过Thread类或实现Runnable...
尚硅谷_宋红康_第8章_多线程.pdf
07-04
本教程特点： 1.更适合零基础学员： ·自Java语言起源始，循序渐进，知识点剖析细致且每章配备大量随堂练习，让你步步为营，学得透彻、练得明白 ·拒绝晦涩难懂的呆板教学，宋老师语言生动幽默，举例形象生动深入浅出，迅速让你把握问题本质，四两拨千斤 2.课程内容推陈出新： ·基于JDK 11，将Java8、Java9、Java10、Java11新特性一网打尽 ·课程中，Eclipse和IDEA这两种企业一线开发环境都使用到了 3.技术讲解更深入、更全面： ·课程共30天，715个知识视频小节，涉及主流Java使用的方方面面，全而不冗余 ·全程内容涵盖数据结构、设计模式、JVM内存结构等深度技术 ·企业级笔试面试题目深入源码级讲解，拒绝死记硬背 4.代码量更大、案例更丰富、更贴近实战： ·Java语言基础阶段：12720行代码，Java语言高级阶段：11684行代码 ·课堂实战项目3套，课后实战项目2套 ·近百道企业面试真题精讲精练、极具实战性
尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
12-27
自己整理的多线程JUC笔记尚硅谷JUC视频笔记整理,很详细和全面，帮你迅速掌握JUC
Java 基础——尚硅谷学习笔记（含面试题） 2023年.zip
最新发布
12-31
Java前后开发面试题，大厂进阶之路，基于JavaGuide、Cyc大佬、牛客...包含计算机网络知识、JavaSE、JVM、Spring、Springboot、SpringCloud、Mybatis、多线程并发、netty、MySQL、MongoDB、Elasticsearch、Redis、HBASE
尚硅谷JAVA基础笔记吐血整理
jiey0407的博客
06-22 1767
第1章 JAVA语言概述第2章 基本语法第3章 数组形参：方法定义时，声明的小括号内的参数实参：方法调用时，实际传递给形参的数据方法的形参传递机制：值传递如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值相同点：1、定义变量的格式：数据类型 变量名=变量值2、先声明后使用3、变量都有其作用域不同点：1、在类中声明的位置不同，属性直接定义在类的{}内，局部变量声明在方法内，方法形参，代码块内，构造器 形参、构造器内部的变量2、权限修
尚硅谷视频总结——Java多线程
qq_51964209的博客
10-10 305
多线程 一：基本概念：程序，进程，线程 程序(program)：程序是为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)：进程是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程：有它自身的产生，存在，消亡的过程。——生命周期。进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。 线程(thread)：进程可进一步细分为多个线程，是一个程序内部执行的一条路径。 若一个程序同一时间并行执行多个线程，则称该程序是支持多线程的 线程作
尚硅谷java基础学习笔记day17
weixin_43808506的博客
08-11 323
尚硅谷java基础学习笔记 day17 com.dg.java package com.dg.java; /** * 多线程的创建，方式一：继承于Thread类 * 1. 创建一个继承于Thread类的子类 * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中 * 3. 创建Thread类的子类的对象 * 4. 通过此对象调用start() * <p> * 例子：遍历100以内的所有的偶数 * * @author shkstart *
【尚硅谷_java基础】九、多线程
weixin_42301220的博客
01-08 1121
文章目录参考资料1. 基本概念：程序、进程、线程1.1 进程与线程1.2 使用多线程的优点1.3 何时需要多线程2. 线程的创建和使用2.1 线程的创建和启动2.2 Thread类2.3 API中创建线程的两种方式2.3.1 方式一：继承`Thread`类的方式2.3.2 方式二：实现Runnable接口2.3.3 继承方式和实现方式的联系与区别2.4 线程的优先级2.5 线程的调度2.6 线程的分类3. 线程的生命周期4. 线程的同步4.1 问题的提出4.2 Synchronized的使用方法5. 线程的
尚硅谷—初级—多线程---（430~447）
张老师的博客
10-23 303
/** * 多线程： * 一：基本概念：程序，进程，线程 * 1.并发：一个 CPU 同时执行多个任务 * 并行：多个 CPU 同时执行多个任务 * * 二：线程的创建和使用 * 1.多线程创建： * （1）方式一：继承于 Thread 类， * （2）方式二：实现 Runnable 接口， * （3）方式三：实现 Callable 接口，（JDK 1.5 之后） * （4）方式四：使用线程池， * 2.Threa.
2021-06-26多线程尚硅谷笔记
weixin_46721333的博客
06-26 130
流程控制 运算符 基本概念：程序、进程、线程 线程的通信 5 JDK5.0新增线程创建方式 68-1 基本概念： 程序、进程、线8.1 基本概念：程序、进程、线程 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一 段静态的代码，静态对象。 进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态 的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的QQ，运行中的MP3播放器 ..
Java多线程学习笔记：线程状态与同步机制
"这篇学习笔记主要探讨了多线程的概念、创建与启动方式、线程方法、线程的生命周期及状态、系统锁synchronized的使用和特性，包括可重入锁和锁升级机制。" 在Java编程中，多线程是一项重要的并发处理技术，它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值