线程的简单学习

最新推荐文章于 2024-07-07 12:38:54 发布
最新推荐文章于 2024-07-07 12:38:54 发布
阅读量168 收藏
点赞数
文章标签： 学习 jvm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58694902/article/details/126274956
版权

1.线程

1.抢占式运行

CPU在执行的时候，按照时间片来执行的，单位的时间片是抢占是执行，比如 idea qq 抢占CPU的，比如qq的线程抢到cpu，idea线程等待

2.资源共享性

一个线程可以共享当前CPU， 网卡等

Java程序:

一个Java程序就是一个进程 Demo1 就是一个应用程序 就是一个进程

一个Java程序Demo1里面至少 几个线程？

两个：

main主函数线程

JVM垃圾回收器线程

2.线程和进程的区别【面试题】

进程是一个应用程序，是独立的
线程是进程中最小的基本单位
线程有独立性和互斥性
线程有抢占式资源共享特性

3.并发和并行

并发：同时发生，轮流交替执行

并行：真正意义上的同时执行

4.创建线程的两种方式【重点】

1.一个是将一个类声明为Thread的子类，这个子类应该重写run方法，然后可以分配并启动子类的实例

package com.qfedu.a_thread;
class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程1吃水煮肉片" + i);
        }
    }
}
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程二吃毛血旺" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MyThread myThread1 = new MyThread();
        myThread1.start();//启动线程 start方法，在主线程中开启子线程
​
        MyThread1 myThread2 = new MyThread1();
        myThread2.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主函数线程吃大盘鸡" + i);
        }
​
    }
}
​

2.创建一个类实现Runnable接口，然后实现run方法，可以分配类的实例，在创建Thread时作为参数传递，并启动

package com.qfedu.a_thread;
​
class MyThread3 implements Runnable{
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程3 " + i);
        }
    }
​
}
class MyThread4 implements Runnable{
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程4 " + i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyThread3 myThread3 = new MyThread3();
        //Thread(Runnable target) 参数是Ruannable这个接口对象
        //分配一个新的Thread对象
        Thread thread = new Thread(myThread3);
        thread.start();
​
        MyThread4 myThread4 = new MyThread4();
        Thread thread1 = new Thread(myThread4);
        thread1.start();
​
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程" + i);
        }
    }
}
​

5.线程下面的几个方法

构造方法

Thread()分配一个新的 Thread对象。 无参构造方法
Thread(Runnable target)分配一个新的 Thread对象。 有参构造
Thread(Runnable target, String name)分配一个新的 Thread对象。并起名字

线程方法：

static ThreadcurrentThread()返回对当前正在执行的线程对象的引用
StringgetName()返回此线程的名称。
voidsetName(String name)将此线程的名称更改为等于参数 name 。
intgetPriority()返回此线程的优先级。
voidsetPriority(int newPriority)更改此线程的优先级。
设置优先并不一定优先，只是增加了执行的概率。最小值是1，最大值是10，默认的是5
static voidsleep(long millis)使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行），具体取决于系统定时器和调度程序的精度和准确性。
package com.qfedu.threadfun;
class MyThread1 implements Runnable{
​
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
        System.out.println(thread.getPriority());
        thread.setName("线程1");
        thread.setPriority(1);
        System.out.println(thread.getName());
        System.out.println(thread.getPriority());
//        for (int i = 0; i < 500; i++) {
//            System.out.println(thread.getName() + " " + i);
//        }
    }
}
class MyThread2 implements Runnable{
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
        System.out.println(thread.getPriority());
        thread.setName("线程2");
        thread.setPriority(10);
        System.out.println(thread.getName());
        System.out.println(thread.getPriority());
//        for (int i = 0; i < 500; i++) {
//            System.out.println(thread.getName() + " " + i);
//        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        new Thread(new MyThread1()).start();
        new Thread(new MyThread2()).start();
        Thread thread = new Thread();
        System.out.println(thread.getName());
        System.out.println(thread.getPriority());
    }
}
​

6.线程的的锁和同步【重要】

为什么要进行线程的同步？

Java是允许多线程（多个线程），当多个线程操作同一个资源（咋操作）的时候，会导致得到或者打印的数据不准确。从而发生冲突。咋解决？加同步锁。

美团
淘票票
这个两个线程，都去麦同一场次的票
结果美团卖出去一张1排1列的票
结果淘票票也卖出去了1排1列的票  你感觉合适吗？
就是上面的这种结果！！！不合适的，分享同一个资源的时候，要保证分享资源的数据，合法性！！！
​
​
​
分析结果:
    
package com.qfedu.c_sync;
​
//最理想的状态！！！
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了， 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是：有可能两个线程同时进入到while循环
//
class MySync implements Runnable {
    int ticket = 50;
    @Override
    public void run() {
        //
        while (true) {//死循环
            //两个线程都进入到了循环了
            //此时两个线程所持有的ticket 都是50
            //但是两个线程都要往下执行
            //有可能线程1 先执行了sout(50)  线程2在等待哦！！！
            //线程1执行了--操作并出了循环 线程1ticket = 49
            //线程1又抢到循环了 sout(49) tiket--
            //再进入倒这个循环，有可能线程2抢到这个执行权
            //线程2要往下执行输出语句  ticket=50 打印50
            if (ticket > 0) {
                //线程具有抢占式的运行
                //咱们有没有可能，线程3进入到if语句
                //此时线程1也进入到if语句了
                //线程3去打印 卖出了50张票
                //在线程1里面  ticket=50
                //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                //线程1又抢到资源要执行，执行输出语句  tiekct=50
                System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                ticket--;
            } else {
                System.out.println("买完了");
                break;//终止循环！！！
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MySync mySync = new MySync();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();
​
​
    }
}
​

解决方案：

1.同步方法:使用一个关键字synchronized修饰方法。因为Java对象都有一个内置的锁对象。当使用这个关键字的时候，修饰方法的时候，这个方法就会被锁保护起来被锁锁住

当一个线程进来以后，会立马锁住当前的方法。意味着只有一个线程进来，其他线程都在外面等着。

public synchronized  void run () {
​
}
package com.qfedu.c_sync;
​
//最理想的状态！！！
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了， 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是：有可能两个线程同时进入到while循环
//
class MySync1 implements Runnable {
    int ticket = 50;
    //对这个run方法加了锁 就意味着只有一个线程进入到run方法中
    //其他线程都在run方法外面等待
    @Override
    public synchronized void run() {
        //
        while (true) {//死循环
            //两个线程都进入到了循环了
            //此时两个线程所持有的ticket 都是50
            //但是两个线程都要往下执行
            //有可能线程1 先执行了sout(50)  线程2在等待哦！！！
            //线程1执行了--操作并出了循环 线程1ticket = 49
            //线程1又抢到循环了 sout(49) tiket--
            //再进入倒这个循环，有可能线程2抢到这个执行权
            //线程2要往下执行输出语句  ticket=50 打印50
            if (ticket > 0) {
                //线程具有抢占式的运行
                //咱们有没有可能，线程3进入到if语句
                //此时线程1也进入到if语句了
                //线程3去打印 卖出了50张票
                //在线程1里面  ticket=50
                //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                //线程1又抢到资源要执行，执行输出语句  tiekct=50
                System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                ticket--;
            } else {
                System.out.println("买完了");
                break;//终止循环！！！
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MySync1 mySync = new MySync1();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();
​
        //为啥都是线程1卖出去的票？
        //很巧  线程1抢到执行权了，进入到run方法中
        //线程2和线程3在外面等着。
        //一个循环进来以后，把循环全部执行完！！！
        //会出现一家独大的情况！！！也是不符合咱们生活场景的！！！
        //咋解决？咱们 不能方法中加锁，在其他地方加锁
​
​
    }
}
​

换另外一种解决方法:

同步代码块:就是拥有了synchronized 关键字修饰一个语句块。被修饰的语句块会被加锁。从而实现同步。

语法格式:

synchronized  (this) {
	被加锁的代码块
}
package com.qfedu.c_sync;

//最理想的状态！！！
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了， 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是：有可能两个线程同时进入到while循环
//
class MySync2 implements Runnable {
    int ticket = 500;
    //对这个run方法加了锁 就意味着只有一个线程进入到run方法中
    //其他线程都在run方法外面等待
    @Override
    public  void run() {
        //能不能对循环加锁？不能 因为循环加锁以后，还是一个线程循环完，没有任何意义

        while (true) {//死循环
            //if语句加了锁以后
            //就意味着只有一个线程进入到if语句
            //假如线程1进入if语句了，线程2和线程3就会等待
            //线程1打印50 并--  ticket变量为49
            //线程2抢到了49 sout(49) tiket--  48
            //其他线程再抢！！！

            //核心业务 加了锁，只让一个线程进入，操作完以后。锁释放掉
            //然后这三个线程再抢。还只能进一个，再操作核心业务
            synchronized (this) {//只能让一个线程进入操作，其他线程在外面等待排队
                if (ticket > 0) {
                    //线程具有抢占式的运行
                    //咱们有没有可能，线程3进入到if语句
                    //此时线程1也进入到if语句了
                    //线程3去打印 卖出了50张票
                    //在线程1里面  ticket=50
                    //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                    //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                    //线程1又抢到资源要执行，执行输出语句  tiekct=50
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                    ticket--;
                } else {
                    System.out.println("买完了");
                    break;//终止循环！！！
                }
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        MySync2 mySync = new MySync2();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();

        //为啥都是线程1卖出去的票？
        //很巧  线程1抢到执行权了，进入到run方法中
        //线程2和线程3在外面等着。
        //一个循环进来以后，把循环全部执行完！！！
        //会出现一家独大的情况！！！也是不符合咱们生活场景的！！！
        //咋解决？咱们 不能方法中加锁，在其他地方加锁


    }
}

线程就是这样，不可控制，但是可以加锁。让他可控制。

烟花易逝，人情长存
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线程的学习
jin1105035079的博客
07-31 78
学习
线程学习总结
weixin_45515971的博客
01-05 267
线程学习 线程池 synchronized底层原理 volatile CAS
线程基础学习小结
qq_42974177的博客
02-17 193
自学
如何学习Java多线程
SexyCode
04-09 3655
最近一段时间，我对《Java并发编程实践》这本经典而又有些难懂的书籍，尝试用了一些简单有趣、通俗易懂的方式进行解读，现整理成GitBook（文末有链接），方便大家阅读。
mfc 多线程学习
05-25
- **MFC与线程**：MFC库为Windows API提供了面向对象的封装，它将线程的创建、同步、通信等功能集成到CWinThread类中，使得在MFC应用中使用多线程变得更加简单。 2. **创建MFC线程** - **CWinThread派生**：创建...
C/C++ 多线程的学习心得总结
09-05
以下是一个简单的C++多线程示例，展示了如何使用 `_beginthreadex()` 创建和管理线程： ```cpp #include #include #include using namespace std; bool stop; unsigned Counter; unsigned __stdcall thread...
线程学习
02-17
线程学习是编程领域中的一个重要概念，特别是在Java这种多线程支持的语言中。Java线程允许程序同时执行多个任务，从而提高系统效率和资源利用率。本文将深入探讨Java线程的相关知识点，帮助你掌握线程的基本操作、...
多线程学习代码
12-21
本文将围绕"多线程学习代码"这个主题，详细讲解其中涉及的Spring动态代理和Java多线程锁的使用，并探讨与JVM特性相关的知识。 首先，让我们来关注Spring框架中的动态代理。动态代理主要分为两种类型：JDK动态代理和...
C++ 线程学习，thread常用操作
02-06
C++11标准引入了`<thread>`库，使得在C++中处理多线程变得标准化和简单化。本教程将深入探讨C++线程的常用操作，包括创建线程、线程同步、线程通信以及线程管理。 1. **线程创建** - `std::thread`构造函数：创建...
Java多线程学习（基础篇）
nelson的博客
08-08 8159
第一节 1. java对线程的支持 java对线程的支持主要体现在Thread类以及Runable接口上，他们都位于java.lang包下，无论是Thread类还是Runable接口，它们都有public void run()方法，这个run方法为我们提供了线程实际工作时的代码，换句话说，我们的逻辑代码就可以写在run方法体中。 2. 线程的创建和启动 3. 线程的常用方法 ...
day11/线程
树上的小桥 的专栏
03-27 463
1      线程的概述 进程：正在运行的程序，负责了这个程序的内存空间分配，代表了内存中的执行区域。 线程：就是在一个进程中负责一个执行路径。 多线程：就是在一个进程中多个执行路径同时执行。   图上的一键优化与垃圾清除同时在运行，在一个进程中同时在执行了多个任务。 假象： 电脑上的程序同时在运行。“多任务”操作系统能同时运行多个进程（程序）——但实际是由于CPU分时机制的
css样式学习样例之边框
最新发布
abments的博客
07-07 827
css样式学习样例之边框
JMH320【亲测】【御剑九歌】唯美仙侠手游御剑九歌+WIN学习手工端+视频教程+开服清档+运营后台+授权GM物品充值后台
m0_71430218的博客
07-05 387
JMH320【亲测】【御剑九歌】唯美仙侠手游御剑九歌+WIN学习手工端+视频教程+开服清档+运营后台+授权GM物品充值后台
学习小记-Netty
weixin_42029860的博客
07-06 215
Netty是由JBOSS个java开源框架，Netty提供异步的、事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
短链接学习day2
weixin_63374588的博客
07-05 882
需要注意的是，转换过程中，BeanUtil.toBean()方法通过反射机制创建了目标类型的实例，并将数据源对象的属性值复制到目标对象中。但是为了防止redis的主节点挂掉后，从节点变成主节点时，有些数据还没复制，就会导致脏数据，就会可能导致用户名重复，所以为了防止这个情况，我们需要将username设置为唯一索引，让数据库兜底。因为用户名不是特别重要的数据，如果说我设置用户名为 aaa，系统返回我不可用，那我大可以在 aaa 的基础上再加一个a，也就是 aaaa。一定要记得写枚举的时候是用逗号分割。
python 多线程学习
11-08
下面是一个简单的Python多线程示例： ```python import threading def worker(): print("Worker is running") # 创建线程对象 thread1 = threading.Thread(target=worker) thread2 = threading.Thread(target=...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值