JavaSE进阶知识学习----多线程基础知识-1

最新推荐文章于 2024-03-11 10:08:19 发布
最新推荐文章于 2024-03-11 10:08:19 发布
阅读量373 收藏 1
点赞数 1
分类专栏： 多线程JUC JAVA进阶学习 文章标签： java 多线程 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27922023/article/details/79168482
版权

多线程基础知识

1.概述程序，进程和线程

程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。
进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。
线程：是进程的小单元，是一个程序内部的一条执行路径。

2.Java中多线程的创建和使用

2.1线程的创建方法之一：继承Thread类，重写Run()方法。

使用说明：
1.定义子类继承Thread类。
2.子类中重写Thread类中的run方法。
3.创建Thread子类对象，即创建了线程对象
4.调用线程对象的start方法，启动线程，调用run方法。

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.start();
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
Thread类常用方法说明

1.start(),启动线程并执行相应的run()方法。
2.run(),子线程要执行的代码放在run()方法中。
3.currentThread(),静态方法，调取当前的线程。
4.getName(),获取此线程的名字。
5.setName(),设置此线程的名字。
6.yield(),调用此方法的线程释放当前cpu的执行权。
以上方法的测试代码如下：

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.setName("我是子线程");
        st.start();
        Thread.currentThread().setName("我是主线程======");
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i % 10 == 0){
                Thread.currentThread().yield();
            }

        }
    }
}

7.join(),在A线程中调用B线程的join()方法，表示A线程执行到此方法，A线程停止执行，直到B线程执行结束，在执行A线程剩余的。
8.isAlive(),判断线程是否还存活。
9.sleep(long long),显示的让当前线程睡眠long毫秒。

class SubThread extends Thread{
    @Override
    public void run() {
        for(int i = 1; i <=100;i++){
            try {
                Thread.currentThread().sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }   
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class TestThread {
    public static void main(String[] args) {
        SubThread st = new SubThread();
        st.setName("我是子线程");
        st.start();
        Thread.currentThread().setName("我是主线程======");
        for(int i = 1; i <=100;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            if(i == 20){
                try {
                    st.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(st.isAlive());
    }
}

10.线程通信：wait(),notify(),notifyAll()
11.getPriority()，返回线程的优先值。
12.setPriority(int newPriority),改变线程的优先级。

继承方式实例

模拟火车站售票窗口，开启三个窗口售票，总票数为100张

class Window extends Thread{
    static int ticket = 100;

    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();

        w1.setName("窗口一");
        w2.setName("窗口二");
        w3.setName("窗口三");

        w1.start();
        w2.start();
        w3.start();
    }
}

注意：ticket只有声明为static,因为三个线程是三个对象，如果不声明为static，三个线程对象就会各自拥有一个ticket=100，使用static修饰后，三个对象共用一个ticket=100。

2.1线程的创建方法之二：实现Runnable接口

1.定义子类，实现Runnable接口。
2.子类重写Runnable接口中的run方法。
3.通过Thread类含参构造器创建线程对象。
4.将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法中。
5.调用Thread类的start方法，开启线程并调用Runnable子类的run方法。

class RunnableDemo implements Runnable{
    @Override
    public void run() {
        for(int i = 1 ; i <= 100; i++){
            if(i % 2 ==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        t1.start();
        Thread t2 = new Thread(ra);
        t2.start();
    }
}
实现方式实例
class RunnableDemo implements Runnable{
    int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+":"+ticket--);
            }else{
                break;
            }
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}
继承方法和实现方法的联系和区别

区别：
继承：线程代码存放在Thread子类的run方法中。
实现：线程代码存放在接口的子类的run方法中。
实现的好处：
1.避免了单继承的局限性
2.多个线程可以共享同一个接口的实现类的对象，适合多个线程来处理同一份资源。

3.线程的调度

3.1调度策略

时间片：就是按时间顺序，先到先执行。
抢占式：高高优先级的线程抢占CPU。

3.2Java中的调度方法

1.同优先级线程组成先进先出队列，使用时间片策略。
2.对高优先级，使用优先调度的抢占式策略。

3.3线程的优先级

MAX_PRIORITY（10）; 最大的优先级
MIN _PRIORITY （1）; 最小的优先级
NORM_PRIORITY （5）; 默认的优先级
getPriority()，返回线程的优先值。
setPriority(int newPriority),改变线程的优先级。
线程的创建时继承父线程的优先级。
优先级别只是说线程抢占CPU的概率增加，并不能说是一定高优先级的先执行完。

4.线程的生命周期

JDK中用Thread.State枚举表示线程的几种状态。
1.新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
2.就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件
3.运行：当就绪的线程被调度并获得处理器资源时,便进入运行状态， run()方法定义了线程的操作和功能
4.阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
5.死亡：线程完成了它的全部工作或线程被提前强制性地中止

5.线程的同步机制

在上面使用继承和实现方法的案例中，有时运行会出现一种情况重票，和负票的情况。这个就是线程安全问题。

线程安全问题原因：

我们创建了多个线程，存在共享数据，那就有可能出现线程安全问题，当其中一个线程操作共享数据时，还未操作完成 ，另外的线程参与进来，导致对共享数据的操作出现问题。

解决方法

要求一个线程操作共享数据结束后，其他线程才能参与进来。

方式一：同步代码块
synchronized(同步监视器){
    //需要被同步的代码块（即为操作共享数据的代码）
}

共享数据：多个线程共同操作的同一数据（变量）。
同步监视器：由一个类的对象来充当，那个线程获取此监视器，谁就执行大括号里面被同步的代码。俗称锁，任何一个类的对象都可以充当锁，要想保证线程的安全，就必须要求所有的线程共用一把锁。（如果将锁放在run方法里，就成了局部变量，就不会保证线程安全）
使用实现的方式中，同步监视器可以使用this，继承的的方式慎用this。

class RunnableDemo implements Runnable{
    int ticket = 100;//共享数据
    @Override
    public void run() {
        while(true){
            synchronized(this){
                if(ticket > 0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket--);
                }
            }
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

在继承方式中，锁只有声明为static才能保证线程安全，

方式二：同步方法

将操作共享数据的方法声明为synchronized，即表明此方法为同步方法。

class RunnableDemo implements Runnable{
    int ticket = 100;//共享数据
    @Override
    public void run() {
        while(true){
            show();
        }
    }
    public synchronized void show(){
        if(ticket > 0){
            try {
                Thread.currentThread().sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+ticket--);
        }
    }
}
public class TestRunnable {
    public static void main(String[] args) {
        RunnableDemo ra = new RunnableDemo();
        Thread t1 = new Thread(ra);
        Thread t2 = new Thread(ra);
        Thread t3 = new Thread(ra);

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

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

同步方法的锁：就时当前对象this。在继承方式中不能使用，因为锁代表当前对象。继承的方式有多个对象。

互斥锁

在Java语言中，为了保证共享数据操作的完整性，引入了对象互斥锁的概念。
每一个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只有一个线程访问改对象。
关键字synchronized来与对象的互斥锁联系，当某一个对象用synchronized修饰时，表明改对象在任一时刻只能由一个线程访问。
同步的局限性会导致程序的执行效率降低。

6.线程的通信

7.使用多线程的优点

1.提高应用程序的响应，增强用户体验。
2.提高计算机系统的CPU利用率。
3.改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于修改和理解。

四川码匠
关注
专栏目录
JAVAEE----多线程1
m0_58157267的博客
03-23 639
上一节我们讲了操作系统中的进程和线程,今天我们继续讲多线程 java中进行多线程编程,操作系统提供了一组关于线程的API(C语言风格),java对于这组API进一步封装之后,就成了Thread类,Thread类来表示/操作线程 总结上面的这段话就是,我们在java中进行多线程编程,需要用到Thread类来和线程打交道 创建好的Thread实例和操作系统中的线程是一一对应的 那下面我们就来说下Thread类的基本用法 通过Thread类创建线程写法有很多种 我........
JavaSE进阶基础这一篇就够了，你值得拥有！
f5465245的博客
12-01 605
本Java视频教程适合有一定编程语言基础的学员观看，在本Java视频教程中讲解了Java开发环境搭建、Java基础语法、面向对象、异常、数组、常用类、集合、IO流、线程、反射机制。该Java视频教程为讲师上课实录，共60个课时（1小时为1个课时），讲师语言表达流利，思路清晰。如果您是有一门编程语言基础的，或者您现在是一名Java程序员且想巩固一下JavaSE的，请打开Java视频教程观看吧！...
JavaSE进阶 | 常用类学习（包装类和日期类详解）
m0_61933976的博客
07-12 1464
JavaSE进阶 | 常用类学习（包装类和日期类详解）
JavaSE进阶
Hello_super的博客
10-29 850
Java接口 | 抽象类 | Object类 | 数组 | String | StringBuffer | 包装类 | Data类 | 数字类 | 随机数 | 异常处理 | ENUM
JavaEE----多线程
m0_61801103的博客
05-12 348
目录 认识线程 概念： 为啥要有线程： 进程和线程的区别： 多线程的优势和缺陷： 线程的状态： Thread：线程 创建线程： 线程的启动 线程的属性： Thread中常用的方法： join（）等待 currentThread() 当前线程 sleep（）休眠 线程的中断 认识线程 概念： 一个线程就是一个 "执行流". 每个线程之间都可以按照顺讯执行自己的代码. 多个线程之间 "同时" 执行着多份代码. 为啥要有线程： 首先, "并发编程" 成为 "刚需....
[Java学习笔记doc]-javase基本知识
08-11
这份"Java学习笔记doc-javase基本知识"涵盖了Java SE的核心概念，对于初学者和有经验的开发者来说都是宝贵的参考资料。 1. **Java语法基础** - **关键字和标识符**：Java的关键字包括`public`, `private`, `...
JavaSE进阶知识汇总(一)
风里有诗句哈的博客
10-08 333
idea使用 创建项目后，先创建模块 file->new->Module idea快捷键 删除一行 ctrl+y 凡是新增或新建的快捷键都是 alt+insert 切换java程序 alt+左右箭头 运行 ctrl+shift+f10 提示方法的参数 ctrl+p alt+数字可以打开对应数字的窗口 光标回到行头和行尾 home和end键 多行注释 ctrl+shift+/ ...
JavaSE进阶每日复习与笔记.zip
11-03
**JavaSE进阶知识点概述** JavaSE（Java Standard Edition）是Java编程语言的基础部分，它提供了用于开发桌面应用程序和服务器端应用的核心库。本压缩包包含的笔记涵盖了JavaSE的一些重要进阶主题，包括抽象类与...
java 线程池实现多并发队列后进先出
04-26
NULL 博文链接：https://hoochiang.iteye.com/blog/2357124
javaee学习日记之java基础之多线程
qq_39576261的博客
08-27 325
多线程（两种方式实现） 一.继承Threadclass Threa extends Thread { @Override public void run() {//线程方法 ss(); } public static void ss() { for (int x = 0; x < 100; x++) { Syst
JavaEE之多线程(进程和线程)详解
最新发布
小源_ 的博客
03-11 994
本文着重讲解了进程和线程的区别和联系。内附图文分析，看完就会！
【JavaEE】多线程基础
qq_53869058的博客
05-11 692
一段代码是这样的：去前台取下 U 盘去教室写 10 分钟作业去前台取下快递如果是在单线程情况下，JVM、CPU指令集会对其进行优化，比如，按 1->3->2的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序编译器对于指令重排序的前提是 “保持逻辑不发生变化”. 这一点在单线程环境下比较容易判断, 但是在多线程环境下就没那么容易了, 多线程的代码执行复杂程度更高, 编译器很难在编译阶段对代码的执行效果进行预测, 因此激进的重排序很容易导致优化后的逻辑和之前不等价.
javaEE 多线程的实现和线程池
qq_45551151的博客
08-08 665
javaEE多线程线程的实现方法一线程的实现方法二实现Runnable于继承Thread相比的优点：线程阻塞 （主动阻塞）线程的中断用户线程和守护线程线程安全问题线程不安全处理1. 同步线程 synchronized 枷锁 线程排队执行 隐式锁（自己创建的）2.显式锁 Lock公平锁（先来先到）和不公平锁（一顿乱抢）；线程死锁多线程通信问题（生产者与消费者）线程的六大状态CallableRunnable 与Callable的相同点Runnable 与Callable的不同点缓存线程池定长线程池周期性任务执行
《JavaEE初阶》多线程基础
simple_person的博客
04-17 1002
本章主要解决一下问题:理解多线程含义理解多线程的创建方法以及基本使用.理解锁的基本概念理解并实现多线程的基本案例我们在理解了进程与线程的基本知识下((784条消息) 《JavaEE初阶》进程与线程_小连~的博客-CSDN博客)引入多线程的基本概念,多线程顾名思义,就是在一个进程中有多个任务,我们希望可以通过进程中创建多个线程来共同完成这个进程中的任务,已达到提高效率的目的.以下列代码为例:一个java进程中,运行main线程: 运行了这个java程序,操作系统就会对应创建一个java进程,同时java进程之
JavaEE进阶知识学习----多线程JUC知识学习
疾风知劲草，智者必怀仁
05-04 491
多线程基础知识 1.概述程序，进程和线程 程序：是为了完成某一特定的功能或任务，用某种语言编写的一段静态代码。 进程：是程序的一次执行过程，它自身有产生，存在和消亡的生命周期。 线程：是进程的小单元，是一个程序内部的一条执行路径。 多线程的创建和使用 创建方法一 继承Thread类，重写Run()方法 使用说明： 定义子类继承Thread类。 子类中重写Thre...
对JavaEE基础多线程基础的理解
KeJason的博客
04-12 657
掌握Executors可以创建的三种线程池的特点及使用范围. 1.1集成Thread类,重写父类run()方法 1.2实现runnable接口 1.3使用ExecutorService、Callable、Future实现有返回结果的多线程(JDK1.5以后) 多线程同步机制 在需要同步的方法的方法签名中加入synchronized的关键字. 使用synchronized块对需要进行同步代码
【JavaEE】第一章线程和多线程
AYuan for Java
05-25 230
企业级：JavaEE 流 集合 面向对象特点：封装 继承 多态 属性的赋值：接口 构造方法 流的应用 常用的字节流 常用的字符流 文件的操作 泛型（常见的集合） 线程简介 java中创建多线程 多线程的同步和死锁 线程简介 程序执行的时候会产生一个进程，一个进程会产生至少一个线程（主线程） （理解线程概念，掌握区别 生命周期 状态） 程序 进程 线程 程序是一段静态的代码，是应用软件执行的蓝本，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值