线程基础学习小结

最新推荐文章于 2023-01-05 17:08:47 发布
最新推荐文章于 2023-01-05 17:08:47 发布
阅读量223 收藏
点赞数
分类专栏： Java 文章标签： 学习 java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42974177/article/details/122985592
版权

创建线程的几种方式：

一：继承

        1. 创建一个类,继承Thread类
        2. 重写父类中的run方法 -> 自己编写线程对象的任务
        3. 创建子类的对象,并调用start()方法启动线程

创建线程类 

public class MyThread extends Thread{
    public MyThread() {
    }

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

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName()+"执行："+i);
        }
    }
}

测试： 

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread("线程1");

        mt.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行："+i);
        }
    }
}

 从图中可知线程交替执行。

线程执行的内存图👇

 

二：实现

    Thread类中的构造方法:
    Thread(Runnable target) 

        1. 准备一个Runnable接口的实现类对象(拿类实现/匿名内部类) ,重写run方法   
        2. 创建Runnable的实现类对象
        3. 创建Thread类对象并把Runnable的实现类对象传递进去
        4. 启动线程

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"hello"+i);
                }
            }
        },"线程名");

        thread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"PHP"+i);
        }
    }
}

 

线程的第三种开启方式(有结果的线程任务)：

Callable<V> 接口 -> 线程的任务接口  V: 线程完成任务后,结果的数据类型
    有且仅有一个方法: V call()
        
中间类 : FutureTask
    FutureTask(Callable<V> callable) 
    FutureTask(Runnable runnable, V result) 
    
类和接口之间的关系:
    1. Runnable接口 是 FutureTask 的父接口
    2. FutureTask(Callable<V> callable) 
    3. Thread(Runnable target)
    
1. 创建Callable<V>的实现类对象,重写call方法编写线程的任务
2. 创建FutureTask对象,并把任务对象传递给FutureTask对象
3. 创建Thread对象,并把FutureTask对象传递给Thread对象
4. 线程对象调用start方法,启动线程

FutureTask类中的V get()方法 : (阻塞方法)
    获取线程执行完毕后的结果,必须要等到线程执行完毕后返回结果才执行!

public class ThreadDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable<String> call = new Callable<String>() {
            @Override
            public String call() throws Exception {
                for (int i = 0; i < 100; i++) {
                    System.out.println("有返回值的线程内部执行");
                }
                return "返回值内容";
            }
        };

        FutureTask<String> ft = new FutureTask<String>(call);

        Thread thread = new Thread(ft);
        thread.start();


        for (int i = 0; i < 1000; i++) {
            System.out.println("main主线程执行："+i);
        }
        System.out.println("ft.get() = " + ft.get());
    }
}

注意：ft.get()方法要放在希望线程交替执行的最后位置，不然会出现

线程并没有交替执行，main主线程执行是在有返回值的线程执行完后再执行了。

线程的名称设置和获取方法：

线程对象名的设置:
    1. 构造方法:
        Thread(String name) 
        Thread(Runnable target, String name) 


    2. 成员方法:
         void setName(String name)  
             
获取线程对象的名称:
    Thread类中的成员方法: String getName()
        
 //若不能直接调用getName(),可以先使用Thread类中的静态方法:
        static Thread currentThread(): 获取当前线程对象

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"hello"+i);
                }
            }
        },"线程名");

        thread.setName("自定义线程名");
        thread.start();
        Thread thread1 = new Thread("自定义线程名2");
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"PHP"+i);
        }
    }
}

 

 获取线程名：  

String name = thread1.getName();
Thread.currentThread().getName()

线程的优先级：

线程的默认优先级 : 5
线程的最小优先级 : 1
线程的最大优先级 : 10
//优先级越高的线程 优先执行的概率越大    

获取线程优先级的方法:
     int getPriority() 
设置线程优先级的方法:
     void setPriority(int newPriority) 

这个有点玄学了，真的运行也并不一定按照设定的优先级来。。。

守护线程：

void setDaemon(boolean on) : 传入true 设置为守护线程

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("a ?");
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("shuile");
            }
        });

        t1.setDaemon(true);

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

守护线程就是保姆线程，在其他所有线程结束后再执行的线程。你吃肉他喝汤刷碗。

线程休眠的方法：

        static void sleep(long millis) : 让线程休眠 -> 休眠多久由传入的毫秒值决定

        休眠 : 线程对象仅仅释放CPU的执行权,不释放锁资源

线程的安全问题（重点）：

        解决线程安全问题的方法有：

        1.同步操作

                同步操作 : 就是上锁的意思

                锁对象具备的特点:
                    1. 唯一
                    2. 能控制所有的线程对象
                    3. 用于做锁的元素必须是引用数据类型 -> 优先推荐: Object
    
                同步后的代码线程对象要执行必须:    
                    1. CPU的执行权
                    2. 锁资源

    2.同步代码块

public class SellTicket1 implements Runnable{
    //总票数 :  共享数据
    int ticket = 100;
    //定义锁对象
    Object obj = new Object();

    @Override
    public void run() {

        //火车站不关门
        while(true){

            synchronized (obj){
                //判断
                if (ticket > 0){

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

                    //买票
                    System.out.println(Thread.currentThread().getName() + "买了第" + ticket + "张票~");
                    //真正的买票
                    ticket--;
                }
            }
        }
    }
}

 3.同步方法

public class SellTicket2 implements Runnable {

    //总票数 :  共享数据
    int ticket = 100;

    @Override
    public void run() {
        //火车站不关门
        while (true) {
            this.sell();
        }
    }

    //同步方法
    //同步方法的锁对象是谁? this
    //静态同步方法的锁对象是谁? 本类的字节码对象 .class对象
    public synchronized void sell() {
        //判断
        if (ticket > 0) {

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

            //买票
            System.out.println(Thread.currentThread().getName() + "买了第" + ticket + "张票~");
            //真正的买票
            ticket--;
        }
    }
}

4.同Lock接口（面向对象的方式上锁）

public class SellTicket3 implements Runnable{
    //总票数 :  共享数据
    int ticket = 100;

    //共享的lock对象
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        //火车站不关门
        while(true){
            //上锁
            lock.lock();
            //判断
            if (ticket > 0){

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

                //买票
                System.out.println(Thread.currentThread().getName() + "买了第" + ticket + "张票~");
                //真正的买票
                ticket--;
            }
            //解锁
            lock.unlock();
        }
    }
}

线程的生命周期：

NEW : 新建 -> 线程对象创建出来了但是没有调用start
BLOCKED : 阻塞 -> 线程醒着但是没有锁资源或者没有CPU执行权
TIMED_WAITING -> 限时等待
    场景1 : 线程对象被调用了sleep(毫秒值) -> sleep: 仅仅丢失CPU执行权,拥有锁资源
    场景2 : 线程对象被调用了wait(毫秒值) -> wait: 丢失锁资源和CPU执行权
WAITING -> 无限等待
    场景 :  线程对象被调用了wait() -> 只有等待被唤醒才能从无限等待状态中复活
RUNNABLE : 运行 -> 拥有CPU执行权,拥有锁对象 正在执行的线程对象
TERMINATED : 死亡 -> 已经死亡的线程状态

 等待和唤醒的方法：

等待和唤醒的方法来自于 Object 类

一般都是使用锁对象控制线程的执行!!
    
唤醒方法: 只是唤醒线程,线程醒了还需要去抢夺CPU资源和锁资源
    void notify() : 随机唤醒一个"沉睡"的线程对象
     void notifyAll() : 唤醒所有"沉睡"的线程对象
        
等待方法: wait : 释放锁和CPU资源
    void wait() : 无限等待 不被调用notify系列方法线程就不会醒  
    void wait(long timeout)  : 限时等待 时间到自己醒或者在中途被唤醒
    void wait(long timeout, int nanos)      

曦曦boy
关注
专栏目录
线程的简单学习
weixin_58694902的博客
08-10 202
System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");因为Java对象都有一个内置的锁对象。...
python 线程的使用 python线程基础知识，提供python2示例代码，供参考学习
08-18
总结，理解Python中的线程概念以及如何在Python2和Python3中使用线程是非常基础且重要的技能。在编写多线程程序时，应关注线程安全、同步问题以及如何有效地利用线程来提升程序的并发能力。同时，了解GIL的存在及其...
线程学习个人总结
Coder_moment的博客
01-04 280
线程学习个人总结 1. 实现多线程的方式 实现Runnable接口，重写run方法 继承Thread类，重写run方法 2. synchronized关键字 synchronized 修饰非静态方法时，取得是对象锁，因此不同线程访问，获取到的是不同的锁，数据互不影响。如需共享资源，需要定义该方法为静态方法。 当一个线程运行时，已进入一个被synchronized修饰的方法中时，调用另一个被s...
线程的学习
z184162946的博客
05-28 280
CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。 学习线程首先要理清楚三个概念： 进程：进程是一个静态的概念 线程：一个进
【java】关于线程的学习总结
bajie2011的博客
09-18 111
●关于线程的描述 当一个应用被执行时，系统就会创建一个进程，进程的入口是主程序，主程序可以被认为是主线程，主线程可以创建一个或多个子线程，并以同步或异步的方式并发（或并行）执行。通常说到“线程”时，是指子线程。 同步或异步，是指同多个子线程之间的相对执行方式。同步执行，是各个子线程按顺序排队，一个执行完再执行另一个；异步执行，是各个子线程同时在执行，异步执行可能造成数据不安全（如果存在对需要共同操作的数据进行修改的话），从而出现预期之外的结果。 并发和并...
0基础学会创建线程相关的知识（内附C语言源码）
小石_coding
03-17 681
0基础学会创建线程相关的知识（内附C语言源码）
多线程基础部分.md，学习代码
最新发布
06-21
在IT行业中，多线程是实现高...总结来说，多线程基础部分的学习涵盖了线程创建、线程状态、线程同步、ThreadLocal的使用以及并发编程的高级概念。通过深入理解这些内容，开发者可以编写出更加高效、稳定的多线程程序。
多线程基础个人总结思维导图
08-15
在IT行业中，多线程是程序并发执行的一种方式，它极大地提高了系统资源的利用率和程序...在学习过程中，可以参考"多线程基础总结01.bmp"和"多线程基础总结01.mmap"等文件，它们可能提供了更为详细和直观的结构化知识。
Java多线程小结
10-26
### Java多线程小结 #### 一、多线程的概念与意义 多线程是Java编程中的一个重要概念，指的是程序在运行时可以同时执行多个线程的能力。它能够提高程序的性能，尤其是在多核处理器的环境下。多线程使得程序能够更...
线程学习总结
weixin_45515971的博客
01-05 295
线程学习 线程池 synchronized底层原理 volatile CAS
线程的基本概念以及线程的创建方式
weixin_34199405的博客
12-04 112
　　 　　　　在接下来的一段时间内会学习多线程相关知识，文章的主要内容是参考&lt;&lt;Java多线程编程核心技术&gt;&gt;，作者高洪岩。 　　　　所有代码中都用到了slf4j日志，主要代替System.out.print功能，而且所有的代码最后整理放在git，git地址:https://github.com/qiao-zhi/ThreadStudy   1.线程相关概念 1....
如何学习Java多线程
SexyCode
04-09 3725
最近一段时间，我对《Java并发编程实践》这本经典而又有些难懂的书籍，尝试用了一些简单有趣、通俗易懂的方式进行解读，现整理成GitBook（文末有链接），方便大家阅读。
Java多线程学习（基础篇）
nelson的博客
08-08 8209
第一节 1. java对线程的支持 java对线程的支持主要体现在Thread类以及Runable接口上，他们都位于java.lang包下，无论是Thread类还是Runable接口，它们都有public void run()方法，这个run方法为我们提供了线程实际工作时的代码，换句话说，我们的逻辑代码就可以写在run方法体中。 2. 线程的创建和启动 3. 线程的常用方法 ...
关于线程的学习心得
越来越好ing的博客
09-13 2736
线程、多线程、并行、并发   1.什么线程 要解释线程，就必须明白什么是进程。 什么是进程呢？     进程是指运行中的应用程序，每个进程都有自己独立的地址空间(内存空间)，比如用户点击桌面的IE浏览器，就启动了一个进程，操作系统就会为该进程分配独立的地址空间。当用户再次点击左面的IE浏览器，又启动了一个进程，操作系统将为新的进程分配新的独立的地址空间。目前操作系统都支持多进程。 要点...
day11/线程
树上的小桥 的专栏
03-27 486
1      线程的概述 进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存中的执行区域。 线程：就是在一个进程中负责一个执行路径。 多线程：就是在一个进程中多个执行路径同时执行。   图上的一键优化与垃圾清除同时在运行，在一个进程中同时在执行了多个任务。 假象： 电脑上的程序同时在运行。“多任务”操作系统能同时运行多个进程（程序）——但实际是由于CPU分时机制的
java多线程学习（超详细吐血总结）
热门推荐
chenruijia170707的博客
11-11 2万+
声明：原文出处http://www.cnblogs.com/nsw2018/p/5822270.html，本人出于学习，收集干货，不作商业用途！以下原作者为林炳文Evankaka的原创作品。转载出处：http://blog.csdn.net/evankakahttp://blog.csdn.net/evankaka/article/details/44153709#t1  （java线程学习的入门...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值