笔记：多线程

最新推荐文章于 2023-08-13 10:02:03 发布
最新推荐文章于 2023-08-13 10:02:03 发布
阅读量57 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62256641/article/details/122272097
版权

一、基本概念

一、程序、进程、线程的理解

二、多线程的创建

方式一、继承继承于Thread类

           * 1. 创建一个继承于Thread类的子类

             * 2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中

           * 3. 创建Thread类的子类的对象

            * 4. 通过此对象调用start()

举例：遍历100以内的所有的偶数

package com.hsy.threadtest;


//1. 创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2. 重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}


public class ThreadTest {
    public static void main(String[] args) {
        //3. 创建Thread类的子类的对象
        MyThread t1 = new MyThread();

        //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
        t1.start();
        //一：我们不能通过直接调用run()的方式启动线程。
//        t1.run();

        //二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
//        t1.start();
        //我们需要重新创建一个线程的对象
        MyThread t2 = new MyThread();
        t2.start();


        //如下操作仍然是在main线程中执行的。
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i + "*main()*");
            }
        }
    }

}

 

方式二、实现Runnable接口

 * 1. 创建一个实现了Runnable接口的类
 * 2. 实现类去实现Runnable中的抽象方法：run()
 * 3. 创建实现类的对象
 * 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5. 通过Thread类的对象调用start()
举例：

//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{

    //2. 实现类去实现Runnable中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }

        }
    }
}


public class ThreadTest1 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }

}

 

 

三、Thread中的常用方法：

 1. start():启动当前线程；调用当前线程的run()方法
 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3. currentThread():静态方法，返回执行当前代码的线程
 4. getName():获取当前线程的名字
 5. setName():设置当前线程的名字
 6. yield():释放当前cpu的执行权
 7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才 结束阻塞状态。
 8. stop():已过时。当执行此方法时，强制结束当前线程。
 9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前 线程是阻塞状态。
 10. isAlive():判断当前线程是否存活

 

 线程的优先级：


 1.
 MAX_PRIORITY：10
 MIN _PRIORITY：1
 NORM_PRIORITY：5  -->默认优先级
2.如何获取和设置当前线程的优先级：
  getPriority():获取线程的优先级
 setPriority(int p):设置线程的优先级

  说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的                    线程高概率的情况下被执行。但并不意味着只有当高优先级的线程执行完以后，低优先                  级的线程才执行。


四、线程的生命周期：

 

五、线程的同步机制（解决线程的安全问题）：

方式一、同步代码块

 synchronized(同步监视器){
       //需要被同步的代码

       }
  说明：

    1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少           了。
      2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
      3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 要求：多个线程必须要共用同一把锁。
 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器
 

方式二：同步方法。

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

1、好处  ：同步的方式，解决了线程的安全问题。 

2、局限性：操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 

六、线程的死锁问题：

     解决线程安全问题的方式三：Lock锁--- JDK5.0新增

 

 

class Window implements Runnable{

    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while(true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if(ticket > 0){

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

                    System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }

        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

七、线程通信：

 面试题：sleep() 和 wait()的异同？

              1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
              2.不同点：   1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明                                              wait()
                                   2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使                                            用 在同步代码块或同步方法中

                                   3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方                                           法中，sleep()不会释放锁，wait()会释放锁。

八、jdk5.0新增的线程的创建方式：

方式三：实现Callable接口。

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？
          1. call()可以有返回值的。

           2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
           3. Callable是支持泛型的

         

//1.创建一个实现Callable的实现类
class NumThread implements Callable{
    //2.实现call方法，将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}


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();

        try {
            //6.获取Callable中call方法的返回值
            //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
            Object sum = futureTask.get();
            System.out.println("总和为：" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

}

方式四：使用线程池

好处：

 1.提高响应速度（减少了创建新线程的时间）
 2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
 3.便于线程管理

     corePoolSize：核心池的大小
    maximumPoolSize：最大线程数
     keepAliveTime：线程没有任务时最多保持多长时间后会终止


 

class NumberThread implements Runnable{

    @Override
    public void run() {
        for(int i = 0;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 = 0;i <= 100;i++){
            if(i % 2 != 0){
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }
    }
}

public class ThreadPool {

    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //设置线程池的属性
//        System.out.println(service.getClass());
//        service1.setCorePoolSize(20);
//        service1.setKeepAliveTime();


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

//        service.submit(Callable callable);//适合使用于Callable
        //3.关闭连接池
        service.shutdown();
    }

}

九、其他 ：

 

 

d&B&
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
JAVA多线程基础知识总结
weixin_43907440的博客
04-21 184
JAVA线程 程序，进程，线程 程序：为了完成特定任务，用某种语言编写的一组指令集和，即指一段静态代码，静态对象 进程：后台在运行的程序，程序的一次执行过程，比如QQ.exe，有其自身的生命周期：产生、存在和消亡的过程，程序是静态的，进程是动态的，进程作为资源分配的范围，系统在运行时会为每一个进程分配不同的内存区域。 线程：进程中的每个活动—线程，比如说QQ中的各项操作应用，同时进行聊天，语音，文...
VB.NET学习笔记：多线程编程
zyjq52uys的博客
04-16 4244
在《多线程加委托实现等待窗体（loading正在加载界面)，运行超时可以取消操作》一文中使用到了多线程编程，在这里做个笔记。 我们继续使用《再谈委托——同步、异步、Lambda 表达式和内置委托》一文的示例代码为本文示例。原文中使用异步委托调用同步方法，即： Private Sub Button1_Click(sender As Object, e As EventArgs) Handles B...
java 多线程相关知识
杰哥哥的专栏
04-05 341
JAVA多线程程序开发基础知识 转载：http://www.panshy.com/articles/201602/dev-2534.html JAVA使用Executor框架实现多线程并发 转载： http://www.panshy.com/articles/201604/dev-2568.html
多线程相关知识（Java）
编程小鹏的博客
08-29 286
一、
Java中多线程的相关知识
个人学习所用博客，记录日常学习的过程。
04-20 628
目录一、创建线程的三种方式1、继承Thread类2、实现runnable接口3、实现Callable接口二、线程的生命周期三、线程常用方法四、线程同步方式1、同步代码块方式2、同步方法方式3、Lock锁4、线程同步的优缺点五、线程通信1、未加线程同步之前2、加线程同步后（1）同步代码块的方式（2）同步方法的方式3、wait()和notify()方法4、进一步优化 一、创建线程的三种方式 1、继承Thread类 新建一个类，当这个类继承Thread类，同时重写Thread类中的run方法，并且线程的任务/逻辑
Java多线程相关知识点
Dwayne的博客
05-09 268
学习记录贴： 1 线程调度 一个CPU在某一时刻只能执行一条指令，线程只有得到 CPU的时间片，也就是使用权才可以执行指令。 1.1 分时调度模型 所有线程轮流获得CPU的使用权； 平均分配每个线程占用CPU的时间片。 1.2 抢占式调度模型 优先让优先级高的线程使用CPU； 优先级相同则随机选择一个； 优先级高的线程获取的CPU时间片相对多一些； 这是java使用的线程调度模型 优先级...
学习笔记：多线程Java Socket编程示例
08-17
在本学习笔记中，我们将探讨如何使用Java的Socket编程实现多线程服务器，特别是通过ExecutorService创建线程池来处理客户端的并发请求。ExecutorService是一个高级的线程管理工具，它允许我们更有效地管理和控制线程...
读书笔记：多线程从入门到精通java之父(余胜军)讲解版本.zip
最新发布
07-26
读书笔记：多线程从入门到精通java之父(余胜军)讲解版本
读书笔记：多线程学习代码《Java并发编程核心方法与框架》相应代码.zip
07-26
读书笔记：多线程学习代码《Java并发编程核心方法与框架》相应代码
花样作死学习笔记：多线程：多线程同时执行同一个程序
qq_21306539的博客
03-23 1818
人就是控制不住自己作死的心理。例如我 学习到了多线程知道了，多线程是提高运行效率最好的办法，当然还有算法。但是我还不会算法，所以用多线程做做死 正好老师出了一道题，在1-4这个4个数字中，生成十个三位数的数字，要求每一个数字都要不相同。同时这十个数字要求不相同。正常逻辑下，运行时间为4，代码应该如下 long start = System.currentTimeMillis(); ...
java多线程相关知识点
diligence-zpf
12-28 386
1.sleep和wait的区别 (1).sleep是Thread中的静态方法,谁调用谁去睡觉,即使在T1线程里调用了T2线程的sleep方法, 实际上还是T1去睡觉。 (2)sleep方法不会释放对象得锁，而wait方法释放了锁. (3)wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用。 2.多线程练习 (1)子线程循环...
JAVA多线程相关知识，看这篇就足够了
Ye_mulin的博客
03-10 372
希望通过《学JAVA，看这篇就足够了》系列，能让读者们深刻理解JAVA相关知识。从小白到大牛，需要一步一步走，一点一点学！ 文章目录希望通过《学JAVA，看这篇就足够了》系列，能让读者们深刻理解JAVA相关知识。从小白到大牛，需要一步一步走，一点一点学！1.多线程的创建（四种方式） 1.多线程的创建（四种方式） 多线程的创建，方式一：继承于Thread类 创建一个继承于Thread类...
Java多线程知识点
makersy的博客
03-24 1217
进程和线程的区别 进程是资源分配的最小单元，线程是CPU调度的最小单元。 所有与进程相关的资源，都被记录在PCB(进程控制块)中 进程是抢占处理机的调度单位；线程属于某个进程，共享其资源 线程只由堆栈寄存器、程序计数器和TCB(线程控制块)组成 总结： 线程不能看做独立应用，而进程可以 进程有独立的地址空间，相互不影响，线程只是进程的不同执行路径 线程没有独立的地址空间，多进程的程序比多线程的程...
java多线程知识点_Java-多线程基础知识点
weixin_28993311的博客
02-22 244
1.进程和线程的基本概念进程是正在进行的程序，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程，多个线程可共享数据。线程就是进程中的一个独立控制单元，一个单一的控制流，线程在控制着进程的执行，一个进程中至少有一个线程。线程和进程的区别内存角度：进程有独立的内存空间，进程中的数据存放空间(堆和栈)是独立的，进程中至少有一个线程；线程实际上没有其独立的内存空间，堆空间是共享的，栈空间是独立...
java多线程知识点合集
songtaiwu的博客
06-17 230
java面试
Java 多线程基础知识整理
Evie的博客
03-22 1340
文章目录多线程概念为什么要用多线程？多线程难点线程生命周期线程调度上下文切换线程创建线程启动线程常用方法用户线程和守护线程补充：定时器机制线程安全概念三性同步与异步编程模型同步机制锁的概念内部锁 synchronizedvolatilesynchronized VS volatileLock（锁）synchronized VS Lock锁的类型可重入锁可中断锁公平锁死锁线程通信生产者消费者模型线程池概述优点线程池的状态处理流程线程池相关 APIExecutorExecutor 两层调度模型Executor
Java多线程知识点总结
qq_44287198的博客
05-20 943
JAVA多线程Java多线程知识点总结（1）什么是进程?什么是线程？（2）多线程的运行状态（3）线程的创建和使用（4）Runnable 接口实现多线程（50）Callable接口实现多线程 Java多线程知识点总结 （1）什么是进程?什么是线程？ 进程： 是并发执行程序在执行过程中分配和管理资源的基本单位，当程序进入内存圆形时即为线程 进程三大特点: 独立性: 进程是系统中独立存在的实体，它可以独立拥有资源，每个进程都有自己的独立空间。 动态性: 进程和程序的区别在于进程动态的，进程具有自己的生命周期 并
Java多线程知识点，看这一篇就够了！（超详细）
weixin_73616913的博客
08-13 4099
1、饿汉模式（迫切）程序启动，类加载之后，立即创建出实例2、懒汉模式（延时）在第一次使用实例的时候，再创建，否则能不创建就不创建举个例子：编译器打开一个文件，假设有一个超大的文件，
java多线程（超详细）
热门推荐
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Groovy学习笔记：多线程、进程处理与模板应用
"Groovy学习笔记，涵盖了多线程运用、处理外部进程、模板使用、Groovlets、数据库编程以及脚本集成等核心知识点。" Groovy是一种强大的、动态的编程语言，它与Java平台紧密集成，可以用于编写脚本、创建应用程序和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

d&B&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值