javaSE线程基础

已于 2022-04-16 09:09:45 修改
阅读量377 收藏
点赞数
分类专栏： 线程 文章标签： java
于 2022-03-23 11:38:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55715292/article/details/123679591
版权

一、创建线程的方法

1.继承Thread

public class 继承Thread {
    public static void main(String[] args){
        T1 t1=new T1();
        T2 t2=new T2();
        t1.start();
        t2.start();
    }
}
class T1 extends Thread {
    public void run(){
        for(int i=0;i<5;i++) {
            System.out.println("你是谁啊");
        }
    }
}
class T2 extends Thread {
    public void run(){
        for(int i=0;i<5;i++) {
            System.out.println("我是线程");
        }
    }
}

运行结果

 需要注意：线程并不是连续且顺序执行的，哪个线程执行主要看CPU给每个线程分配到的时间

2.实现Runnable接口

public class 实现Runnable {
    public static void main(String[] args){
        //创建一个线程要执行的任务
        T t=new T();
        //创建一个线程
        Thread thread=new Thread(t);
        //启动线程
        thread.start();
    }
}
class T implements Runnable{

    @Override
    public void run() {
        System.out.println(1111111);
    }
}

 运行结果：

 3.实现Callable接口

public class 实现Callable {
    public static void main(String[] args){
        CallableTest callableTest=new CallableTest();
        FutureTask<String> futureTask=new FutureTask(callableTest);
        futureTask.run();
        try {
            String st=futureTask.get();
            System.out.println(st+"====");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class CallableTest implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println("任务开始了");
        Thread.sleep(1000);
        return null;
    }
}

运行结果：

 这种创建线程方式需借助FutureTask类来实现

与实现Runnable接口的方式相比，可以在方法上抛出异常且有返回值

4.也可以通过匿名内部类的方式来创建线程

public class 匿名内部类的方式创建线程 {
    public static void main(String[] args){
        Thread thread=new Thread(){
            public void run(){
                System.out.println("我是线程");
            }
        };
        thread.start();
    }
}

这种方式等同于继承Thread

二、线程睡眠

Thread.sleep()方法可以令线程阻塞一段时间

public class 线程睡眠 {
    public static void main(String[] args){
        Thread thread=new Thread(){
            public void run(){
                Scanner sc=new Scanner(System.in);
                int f=sc.nextInt();
                while(f>=0){
                    System.out.println(f);
                    f--;
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread.start();
    }
}

三、线程并发安全问题

两个或多个进程并发访问共享数据，共享数据的最终结果取决于进程运行的精确时序，这种情况称为竞争条件。为了防止竞争条件的发生，并发进程需要进行同步，也就是给共享资源安上一把锁（synchronized）

1.未加锁

public class 线程并发安全问题 {
    static Object o=new Object();
    public static void main(String[] args){
        Thread t1=new Thread("小龙女"){
            public void run(){
                getBean(Thread.currentThread().getName());
            }
        };
        Thread t2=new Thread("李莫愁"){
            public void run(){
                getBean(Thread.currentThread().getName());
            }
        };
        t1.start();
        t2.start();
    }
    public static void getBean(String name){
        System.out.println(name+"进入商场");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name+"挑衣服");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "进试衣间");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "试衣服");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "出试衣间");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name+"走出商场");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

很明显，商场可以多个人一起进入，挑选衣服与离开商场也是可以同时进行，但当商场只有一个试衣间时，是不能两个人同时进入试衣间的，这时这个试衣间内的活动就是我们所说的共享资源，为了让多人使用这个共享资源不会发生冲突，我们需要给共享资源加上一把锁

 2.加上锁

public class 线程并发安全问题 {
    static Object o=new Object();
    public static void main(String[] args){
        Thread t1=new Thread("小龙女"){
            public void run(){
                getBean(Thread.currentThread().getName());
            }
        };
        Thread t2=new Thread("李莫愁"){
            public void run(){
                getBean(Thread.currentThread().getName());
            }
        };
        t1.start();
        t2.start();
    }
    public static void getBean(String name){
        System.out.println(name+"进入商场");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name+"挑衣服");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (线程并发安全问题.class) {
            System.out.println(name + "进试衣间");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "试衣服");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "出试衣间");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(name+"走出商场");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


    }
}

运行结果

 当有线程在使用共享资源时，其他线程处于阻塞态，等待CPU给分配使用共享资源

四、加塞阻塞（插队）

当我们在打扫屋子时，我们需要先扫地，当地面扫干净后，我们才能拖地；而不能扫地和拖地一起进行或是先拖地后扫地，这时我们就需要做一个执行的顺序要求join()

public class 加塞阻塞or插队 {
    public static void main(String[] args){
        Thread t1=new Thread(){
            public void run(){
                for(int i=0;i<5;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("我扫");
                }
                System.out.println("扫完了");
            }
        };
        Thread t2=new Thread(){
            public void run(){
                try {
                    t1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for(int i=0;i<5;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("我拖");
                }
                System.out.println("拖完了");
            }
        };
        t1.start();
        t2.start();
    }
}

运行结果：

 五、守护线程

拿一个小案例来说明

public class 守护线程 {
    public static void main(String[] args){
        Thread t1=new Thread(){
            public void run(){
                for(int i=0;i<5;i++){
                    System.out.println("i will jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("噗通。。。。。");
            }
        };
        Thread thread2=new Thread(){
            public void run(){
                while(true){
                    System.out.println("you jump! i jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        thread2.start();
    }
}

在没有添加守护线程的条件下，thread2是不会受t1线程终止的影响而终止的

 但是当我们将thread2设置为守护线程后，t1停止thread2就会停止

public class 守护线程 {
    public static void main(String[] args){
        Thread t1=new Thread(){
            public void run(){
                for(int i=0;i<5;i++){
                    System.out.println("i will jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("噗通。。。。。");
            }
        };
        Thread thread2=new Thread(){
            public void run(){
                while(true){
                    System.out.println("you jump! i jump!");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        thread2.setDaemon(true);
        t1.start();
        thread2.start();
    }
}

 其实java的public static void main(String[] args){} 就是一个守护线程

六、栅栏

当很多人约定好一个时间地点集合然后出发，我们需要保证当凑够五个人到了后才可以出发，这时我们可以设置一个栅栏(CyclicBarrier)

public class 栅栏CyclicBarrier {
    public static void main(String[] args){
        CyclicBarrier cb=new CyclicBarrier(5);
        for(int i=0;i<14;i++){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Thread t=new Thread(){
                public void run(){
                    System.out.println("栅栏等待");
                    try {
                        cb.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    System.out.println("出发");
                }
            };
            t.start();
        }
    }
}

运行结果：

 因为一共就只有14个人，前十个人都可以正常出发，最后四个人因为凑不够五个人需要一直等待，线程处于阻塞状态

七、闭锁

因为线程是靠CPU分配时间来执行的，我们并不知道CPU会给线程分配到什么时间，但有时我们必须要求一个线程任务在某一时段执行，这时我们可以将所需线程加上一把锁(CountDownLatch)只有执行了所要求的线程数量后，才可以执行这个线程任务

public class 闭锁CountDownLatch {
    public static void main(String[] args){
        CountDownLatch cdl=new CountDownLatch(3);
        Thread t1=new Thread(){
            public void run(){
                System.out.println("准备发射。。。。。");
                cdl.countDown();
            }

        };
        Thread t2=new Thread(){
            public void run(){
                System.out.println("检查冷却装置。。。。。");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("冷却装置检查完毕");
                cdl.countDown();
            }
        };
        Thread t3=new Thread(){
            public void run(){
                System.out.println("检查氧气装置。。。。。");
                try {
                    Thread.sleep(20000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("氧气装置检查完毕");
                cdl.countDown();
            }
        };
        Thread thread=new Thread(){
            public void run(){
                try {
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("点火发射");
            }
        };
        t1.start();
        t2.start();
        t3.start();
        thread.start();
    }
}

我们将锁加在了点火发射的线程任务上

运行结果：

 八、睡眠阻断

可以通过interrupt()方法，将处于睡眠状态的线程阻断其睡眠，令其继续执行

public class 睡眠阻断 {
    public static void main(String[] args){
        Thread thread1=new Thread(){
            public void run(){
                try {
                    Thread.sleep(2000000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("睡美人说 哎呀妈呀 破了相了");
            }
        };
        Thread thread2=new Thread(){
            public void run(){
                for(int i=0;i<10;i++){
                    System.out.println("八十");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("墙破了");
                thread1.interrupt();
            }
        };
        thread1.start();
        thread2.start();
    }
}

九、volatile 共享变量

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰后，那么就具备了两层语义：

1、保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的

2、禁止进行指令重排序

Mr.Sun1127
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE-线程
weixin_52972575的博客
11-27 400
线程
JavaSE 多线程资料
04-06
在Java中，线程是程序执行的最小单位，与进程一同构成了操作系统的基础运行模型。 首先，线程是进程中的一个执行路径，每个进程至少包含一个主线程。操作系统中的进程彼此独立，拥有各自的内存空间，而线程则共享...
JavaSE入门学习50：多线程编程(一)
life is wonderful
06-18 2801
一进程和线程         (1)进程和线程的基本概念         进程：程序(任务)的执行过程；持有资源(共享内存，共享文件)和线程。         线程：是一个程序内部的顺序控制流。         我们生活中的进程例子很多，一个进程就相当于一个你在电脑上启动的程序。比如我们打开最常用的聊天工具 QQ，也可以打开Java的开发工具Eclipse等等。这些都算Window操作系
java SE 线程
cz19982538的博客
08-15 87
一、线程 线程的使用：创建线程的方式： 方式一： 构建一个类继承线程Thread类 重写Thread类的run(); 创建线程对象; 开启线程：对象.start(); 方式二：(可拓展性强，接口可以多继承多实现) 实现Runnable接口的类，实现run(); 创建线程对象; new Thread(线程对象).start();//start()是Thread独有的 每开启一个线程都...
Java SE 线程总结
qq_55931044的博客
04-26 266
线程 程序，进程，线程 线程和进程的关系 创建线程 继承Thread类的方式 实现Runnable接口 实现Callable接口的方式. Thread类中的方法 线程的优先级 线程的状态 线程的分类 多线程 多线程的概念 什么时候需要用多线程 多线程的缺点 多线程的优点 并行与并发 线程同步 同步锁 synchronized 多线程买火车票问题 Lock（锁） 线程死锁 线程通信 经典例题：生产者/消费者问题
JAVA语言基础_线程、线程池、Lambda表达式
weixin_34097242的博客
05-01 243
2019独角兽企业重金招聘Python工程师标准>>> ...
JavaSE基础面试题.docx
06-11
JavaSE基础面试题涵盖了许多核心概念，以下是这些知识点的详细说明： 1. **面向对象的特征**：包括封装、继承和多态。封装是隐藏对象的属性和实现细节，仅对外提供公共访问方式；继承是子类继承父类的属性和方法，...
JavaSE基础课件
12-03
这个“JavaSE基础课件”包含了全面的Java编程基础知识，对于初学者和有经验的程序员来说，都是一个宝贵的资源，可以用来学习、复习或者巩固Java编程技能。 在JavaSE的学习中，首先会接触到的是基础语法，包括变量、...
01JavaSE基础.zip
06-04
本压缩包"01JavaSE基础.zip"包含的是作者根据动力节点的Java零基础教程视频编写的笔记，这些笔记详细地概述了Java SE的基本概念和核心特性，旨在帮助初学者更好地理解和掌握Java编程。 1. **Java环境搭建**：首先，...
JavaSE基础教程（新手必读）
05-19
对于初学者来说，理解并掌握JavaSE的基础知识是学习Java编程的第一步。本教程旨在帮助新手快速入门，理解Java语言的基本概念、语法以及常用API的使用。 一、Java编程语言基础 1. **变量与数据类型**：Java支持基本...
day_19 JavaSE 线程
sinat_42759524的博客
08-14 230
# 线程 ##多线程应用--输出不产生交错 t1  输出 ++++++++++++++ t2 输出 ----------------------- t3 输出  **************** ##按顺序输出  定义一个整形变量flag t1 obj.wait()  flag==1 t2 obj.wait() flag ==2 t3 obj.wait() flag ==3  jdk ...
javaSE学习——线程
雷神乐乐的博客
11-14 322
了解线程的相关概念，有习题
JavaSE——线程详解
winner_20020626的博客
10-28 165
JavaSE——线程详解程序、进程、线程线程的创建方式一（Thread)：方式二（Runnable)：方式三（Callable)：Lambda表达式线程控制线程的状态：线程状态的转换：线程的主要方法：停止线程线程休眠线程礼让线程插队线程状态观测线程优先级守护线程线程互斥和同步操作系统中的进程互斥与同步Java中的线程互斥和同步线程互斥**synchronized方法****synchronized块**Lock锁优先使用顺序线程同步线程通信的几个方法：实现线程同步的示例（以生产者-消费者模式为例）：线程池方
JavaSE 多线程
ReverieZH的博客
09-25 301
同一个时间完成一个事情就是单线程 同时进行多个事情就是线程机制 并发与并行 并行是指两个或者多个事件在同一时刻发生 并发是指两个或多个事件在同一时间间隔发生。 可以这么看，并行就是真的同时在干多个事情，吃牛排时，你左手拿叉右手拿刀，两个手一块操作牛排，这就是并行 并发可以看做是一个假的同时。就是在一个时间T内，你把这个时间分为很多个小的时间段t1tn，这样有形成了很多个时间间隔ti，在这每一个时间...
JavaSE -- 多线程
rbx508780的博客
09-26 232
📕 JAVASE多线程超详细知识点总结 1.相关概念 2.线程的创建与启动 3.Thread类 4.线程的生命周期状态 5.线程安全问题 6.等待唤醒机制 7.释放锁操作与死锁
Java SE 线程
weixin_62972462的博客
02-06 320
什么是进程 独立的应用程序 进程是需要通过系统的分配，获取系统当前的CPU，内存，显卡，网络等这些资源 独立性 互斥性 进程可以类似等于是软件 什么是线程 线程是组成进程的最小基本单位，每一个进程至少有一个线程 线程的运行支撑起来进程的运行 人是一个进程的话 那么 细胞就是一个线程 线程具有什么特点： 1.抢占式运行【重点】 CPU在执行的时候，是按照时间片进行执行的，单位的时间片是相互抢占的 比如是40ms 比如qq下面有两个线程, 一个线程抢到资源，40ms
JavaSE第十章.线程
qq_52163230的博客
08-04 258
目录程序进程线程线程和进程的关系创建线程1.继承Thread类2.实现Runnable接口Thread类中的常用方法放缓休眠线程优先级线程状态线程的分类用户线程守护线程多线程概念何时需要多线程优点缺点线程同步并发与并行多线程同步synchronized修饰代码块修饰方法LOCK线程死锁产生死锁的原因产生死锁的必要条件线程通信新增创建线程方式 程序进程线程 程序 程序(program),是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码 进程 进程((process),就是正在执行的
javase之线程基本信息
Richard_666的博客
02-23 122
JavaSE 15 多线程
loetca
04-21 2082
JavaSE 15 多线程
javaSE基础项目实战
最新发布
06-01
5. 多线程编程练习：包括JavaSE中的多线程编程知识，如线程的创建、同步、互斥等的练习。 6. 数据库操作练习：包括JavaSE中的数据库操作，如JDBC连接、SQL语句的执行等的练习。 通过以上练习，初学者可以更好地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值