Java-多线程入门学习

已于 2022-08-28 16:50:25 修改
阅读量83 收藏
点赞数
分类专栏： 笔记 java 文章标签： java 学习 jvm
于 2022-07-24 17:52:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55850954/article/details/125959509
版权
笔记 同时被 2 个专栏收录
48 篇文章 1 订阅
订阅专栏
java
29 篇文章 0 订阅
订阅专栏

Java-多线程入门学习

1.继承Thread类

demo01
Thread1.class

class Thread1 extends Thread{
    private String name;
    public Thread1(String name){
        this.name=name;
    }
    //一定要重写run函数
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println(name+"运行:"+i);
            try{
                sleep((int)Math.random()*10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

主函数：

 public static void main (String args[]) {
       Thread1 thread1=new Thread1("CXY");
       Thread1 thread2=new Thread1("dhi");
       Thread1 thread3=new Thread1("DHY");
       thread1.start();
       thread2.start();
       thread3.start();
    }

Thread的一些常用方法=================

Thread.currentThread().getName();//获取线程名
Thread.currentThread().getPriority();//获取线程优先级

当子线程需要主线程的一些资源时，主线程必须比子线程晚结束，因此要使用到join

未使用join的情况=========================：

class Thread1 extends Thread{
    private String name;
    public Thread1(String name){
        super(name);
        this.name=name;
    }
    public void run(){
        System.out.println(Thread.currentThread().getName()+"线程运行开始！");
        for(int i=0;i<5;i++){
//            System.out.println(name+"运行："+i);
            System.out.println("子线程"+name+"运行 "+i);
            try{
                sleep((int)Math.random()*10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程运行结束");
    }
      public static void main (String args[]) {
        System.out.println(Thread.currentThread().getName()+"主线程运行开始");
        Thread1 thread1=new Thread1("A");
        Thread1 thread2=new Thread1("B");
        thread1.start();
        thread2.start();
        System.out.println(Thread.currentThread().getName()+"主线程运行结束");
    }
}

结果如下：
在这里插入图片描述
很明显，子线程结束前，主线程就结束了。

使用join===============================

class Thread1 extends Thread{
    private String name;
    public Thread1(String name){
        super(name);
        this.name=name;
    }
    public void run(){
        System.out.println(Thread.currentThread().getName()+"线程运行开始！");
        for(int i=0;i<5;i++){
//            System.out.println(name+"运行："+i);
            System.out.println("子线程"+name+"运行 "+i);
            try{
                sleep((int)Math.random()*10);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"线程运行结束");
    }
      public static void main (String args[]) {
        System.out.println(Thread.currentThread().getName()+"主线程运行开始");
        Thread1 thread1=new Thread1("A");
        Thread1 thread2=new Thread1("B");
        thread1.start();
        thread2.start();
        try{
        	thread1.join();
        }catch(InteruptedException e){
        	e.printStackTrace();
        }
        try{
        	thread2.join();
        }catch(InteruptedException e){
        	e.printStackTrace();
        }
        
        System.out.println(Thread.currentThread().getName()+"主线程运行结束");
    }
}

结果如下：
在这里插入图片描述

yield():暂停当前正在执行的线程对象，并执行其他线程。
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。
yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。
结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。可看上面的图。

class ThreadYield extends Thread{
    public ThreadYield(String name){
        super(name);
    }
    @Override
    public void run(){
        for(int i=1;i<=50;i++){
            System.out.println(""+this.getName()+"-----------"+i);
            //当i=30时,将CPU时间让掉，让其他线程或者自己的线程执行
            if(i==30){
                this.yield();
            }
        }
    }
    public static void main (String args[]) {
        ThreadYield yt1=new ThreadYield("张三");
        ThreadYield yt2=new ThreadYield("李四");
        yt1.start();
        yt2.start();
    }
}

结果如下：
在这里插入图片描述
在这里插入图片描述
多次测试后，我们可以发现，每次有一个线程到达30时，就会切换把CPU让给另一个线程,当也不是绝对的。

sleep和yeild的区别
在这里插入图片描述

线程数据传递方法
1.通过构造函数传递

class MyThread1 extends Thread{
    private String name;
    public MyThread1(String name){
        this.name=name;
    }
    public void run(){
        System.out.println("hello "+name);
    }
    public static void main (String args[]) {
        Thread thread=new MyThread1("world");
        thread.start();;
    }
}

因为是通过构造函数进行传递，所以在线程运行之前数据已经到位，不会造成数据在线程运行后才传入的现象。但是如果数据比较多时，可能要有多个构造函数，比较不方便。
2.通过变量和方法传递

public class MyThread2 implements Runnable   
{   
private String name;   
public void setName(String name)   
{   
this.name = name;   
}   
public void run()   
{   
System.out.println("hello " + name);   
}   
public static void main(String[] args)   
{   
MyThread2 myThread = new MyThread2();   
myThread.setName("world");   
Thread thread = new Thread(myThread);   
thread.start();   
}   
}

建立完对象后，对对象实例逐个赋值，这样可以避免建立太多构造函数
3.通过回调函数传递数据

class Data{
    public int value=0;
}
class Work{
    public void process(Data data,Integer... numbers){
        for(int n:numbers){
            data.value+=n;
        }
    }
}
class MyThread3 extends Thread{
    private Work work;
    public MyThread3(Work work){
        this.work=work;
    }
    public void run(){
        Random random=new Random();
        Data data=new Data();
        int n1=random.nextInt(1000);
        int n2=random.nextInt(2000);
        int n3=random.nextInt(3000);
        work.process(data,n1,n2,n3);
        System.out.println(String.valueOf(n1)+"+"+String.valueOf(n2)+"+"+
                String.valueOf(n3)+"="+data.value);
    }
     public static void main (String args[]) {
        Thread thread=new MyThread3(new Work());
        thread.start();
    }
}

2.继承Runnable类

实际开发中，通常采用Runnable接口来实现多线程，优点如下：
1.避免继承的局限，一个类可以继承多个接口，但类只能继承一个类
2.Runnable接口实现的线程便于资源共享，而通过Thread类实现，各自线程（继承子类创建的线程）的资源是独立的，不方便共享

class MyThread implements Runnable{
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("你好，DHI");
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
     public static void main (String args[]) {
        MyThread myThread=new MyThread();
        Thread thread=new Thread(myThread);
        thread.start();
    }
}

未使用同步锁时==============

class Run implements Runnable{
    private int count=1;
    @Override
    public void run(){
        for(int i=0;i<20;i++){
            System.out.println(Thread.currentThread().getName()+"运行 "+count++);
        }
    }
    public static void start(){
        Run r=new Run();
        new Thread(r,"线程A").start();
        new Thread(r,"线程B").start();
        new Thread(r,"线程C").start();
    }
    public static void main (String args[]) {
        Run.start();
    }
}

在这里插入图片描述
很明显可以看出，这个是线程不安全的，多个线程有可能在同一时间操作变量

同步锁==============

class Run implements Runnable{
    private int count=1;
    @Override
    public void run(){
        synchronized (this){
            for(int i=0;i<20;i++){
                System.out.println(Thread.currentThread().getName()+"运行 "+count++);
            }
        }
    }
    public static void start(){
        Run r=new Run();
        new Thread(r,"线程A").start();
        new Thread(r,"线程B").start();
        new Thread(r,"线程C").start();
    }
    public static void main (String args[]) {
        Run.start();
    }
}

在这里插入图片描述
很明显，这样做可以保证线程安全
在举个例子如下：
没同步锁的：

class MyThread implements Runnable{
    private static int count=0;
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.println("name="+Thread.currentThread().getName()+",count="+count++);
        }
    }
    public static void main (String args[]) {
        MyThread r1=new MyThread();
        MyThread r2=new MyThread();
        MyThread r3=new MyThread();
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        Thread t3=new Thread(r3);
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述
加同步后：

class MyThread implements Runnable{
    private static int count=0;
    @Override
    public void run(){
    synchronized(this){
        for(int i=0;i<10;i++){
            System.out.println("name="+Thread.currentThread().getName()+",count="+count++);
        }
        }
    }
    public static void main (String args[]) {
        MyThread r1=new MyThread();
        MyThread r2=new MyThread();
        MyThread r3=new MyThread();
        Thread t1=new Thread(r1);
        Thread t2=new Thread(r2);
        Thread t3=new Thread(r3);
        t1.start();
        t2.start();
        t3.start();
    }
}

在这里插入图片描述
这里还是不同步的？原因是因为同步的对象不是同一个

卖票问题*

class Client implements Runnable{
    private int count=30;
    @Override
    public void run(){
        synchronized (this){
            while(count>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+count--+"张票");
            }
        }
    }
    public static void start(){
        Client c=new Client();
        new Thread(c,"线程A").start();
        new Thread(c,"线程B").start();
        new Thread(c,"线程C").start();
    }
}
public class demo {
    public static void main (String args[]) {
        Client.start();
    }
}

在这里插入图片描述

参考连接
Java多线程学习（吐血详细整理）
java多线程入门
Java并发编程系列2.0：实现Runnable接口方式实现多线程
java多线程之：实现Runnable接口

3.获取返回值

在刚才的示例中，我们都是通过继承Thread或Runnable的，但是这两者都无法获取返回值，在一些项目中，我们需要获取线程的返回值，这时候就可以使用Callable和Future了
继承Callable后，要实现call接口

public class Main {
    static class MyThread implements Callable<Integer>{
        private int num;
        public MyThread(Integer num){
            this.num=num;
        }
        @Override
        public Integer call(){
            int result=0;
            long start=System.currentTimeMillis();
            for(int i=0;i<num;i++){
                result+=num;
                try{
                    Thread.sleep(100);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            long end=System.currentTimeMillis();
            System.out.println("线程"+Thread.currentThread().getName()+"用时："+(end-start));
            return result;
        }
    }
    public static void main(String[]args) {
        MyThread thread1=new MyThread(20);
        MyThread thread2=new MyThread(30);
        MyThread thread3=new MyThread(40);
        ExecutorService service= Executors.newFixedThreadPool(3);
        long start=System.currentTimeMillis();
        try{
        	//获取结果
            Future<Integer>future1=service.submit(thread1);
            Future<Integer>future2=service.submit(thread2);
            Future<Integer>future3=service.submit(thread3);
            System.out.println("future1"+future1.get());
            System.out.println("future2"+future2.get());
            System.out.println("future3"+future3.get());
        }catch (Exception e){
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println("用时："+(end-start));
        service.shutdownNow();
    }
}

注意，在上面的实例中，当我们使用future.get（）时，会先将对应的进行运行完，然后才会继续往下执行，这是上述代码的执行结果
在这里插入图片描述
我们将get的顺序修改一下

 public static void main(String[]args) {
        MyThread thread1=new MyThread(20);
        MyThread thread2=new MyThread(30);
        MyThread thread3=new MyThread(40);
        ExecutorService service= Executors.newFixedThreadPool(3);
        long start=System.currentTimeMillis();
        try{
            Future<Integer>future1=service.submit(thread1);
            System.out.println("future1"+future1.get());
            Future<Integer>future2=service.submit(thread2);
            System.out.println("future2"+future2.get());
            Future<Integer>future3=service.submit(thread3);
            System.out.println("future3"+future3.get());
        }catch (Exception e){
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println("用时："+(end-start));
        service.shutdownNow();
    }

结果如下
在这里插入图片描述
参考文章：JAVA的Callable多线程

4.线程间通信

线程间可以通过管道来进行通信

public class Main {
    static class Producer extends Thread{
        private PipedWriter pipedWriter;
        private String content;
        public Producer(PipedWriter pipedWriter,String content){
            this.pipedWriter=pipedWriter;
            this.content=content;
        }
        @Override
        public void run(){
                    System.out.println("进入Producer");
            try{
                pipedWriter.write(content);
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    static class Consumer extends Thread{
        private PipedReader pipedReader;
        public Consumer(PipedReader pipedReader){
            this.pipedReader=pipedReader;
        }
        @Override
        public void run(){
                    System.out.println("进入Consumer");
            try{
                char[]sb=new char[20];
                pipedReader.read(sb,0,sb.length);
                System.out.println("数据为："+new String(sb));
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    public static void main(String[]args){
       PipedWriter pipedWriter=new PipedWriter();
       PipedReader pipedReader=new PipedReader();
       Producer producer=new Producer(pipedWriter,"HelloWorld----------");
       Consumer consumer=new Consumer(pipedReader);
       try{
           pipedWriter.connect(pipedReader);
           producer.start();
           consumer.start();
       }catch (IOException e){
           e.printStackTrace();
       }catch (Exception e){
           e.printStackTrace();
       }
    }
}

在这里插入图片描述
参考文章：PipedReader和PipedWriter使用详解及源码分析

沉河不浮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA-线程的入门记录
06-17
多线程
java 线程中yield的用法
LzwGlory的专栏
09-28 955
Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。 yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。 结论：yield()从未导致线程转到
Scala中的yield关键字| for / yield示例
为了更好的未来_加油
12-09 708
Scala yield关键字 Scala中的yield关键字与for循环一起使用。它在每个for循环迭代中存储一个变量。存储的变量组合在一起，以创建与for循环在同一时间运行的新结构。例如，在映射上使用yield会为列表，数组向量等提供类似的映射结构。 yield的语法是 for (loop condition) yield variable; 示例，使用yield与for循环，循环从1到5 for (i <- 1 to 5) yield (i*5) 输出结果 scala.collection.i
每日一题：java基础
qq_44713772的博客
04-06 2240
下列整型常量 i 的定义中，正确的是( ) A、final i; B、static int i; C、static final int i=234; D、final float i=3.14f; 答案：C 题解：static final int,常量代表的是被static和final修饰的。 关于以下application,说法正确是什么？ A、4行与9行不能通过编译，因为缺少方法名和返回类型 B、编译通过，执行结果是：x=5 C、编译通过，执行结果是：x=3 D、9行不能通过编译，因为只能有.
sleep()和yield()有什么区别?
ConstXiong
12-18 980
sleep() 方法给其他线程运行机会时不考虑线程的优先级；yield() 方法只会给相同优先级或更高优先级的线程运行的机会 线程执行 sleep() 方法后进入阻塞状态；线程执行 yield() 方法转入就绪状态，可能马上又得得到执行 sleep() 方法声明抛出 InterruptedException；yield() 方法没有声明抛出异常 sleep() 方法需要指定时间参数；yiel...
【Java用法】Java线程中yield()和join()的用法以及注意事项
No8g攻城狮的博客
05-14 3507
本文目录 一、yield的意思 二、yield()的作用 三、yield()的结论 四、Java线程优先级 五、yield()注意事项 六、join()方法 一、yield的意思 yield的中文意思是放弃，投降的意思。当前线程调用yield的时候，是告诉虚拟机它愿意让其他的线程抢占自己的位置或者表明该线程没有紧急的事要做，但这只是一种暗示，并不能保证一定会发生。 二、yield()的作用 Thread.yield()方法的作用：暂停当前正在执行的线程，并执行其他同等优先级的线程。（可.
零基础Java入门课程-多线程
07-01
本"零基础Java入门课程-多线程"专为初学者设计，旨在通过最新的Java 14平台，引领学习者逐步掌握Java的基础及多线程相关知识。 Java集合框架是Java编程中的核心组成部分，它提供了对数据结构的有效管理，包括数组、...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java多线程入门的源代码
03-28
Java多线程是Java开发中的重要概念，它允许程序同时执行多个任务，提高了程序的效率和响应速度。在Java中，实现多线程有两种主要方式：继承Thread类和实现Runnable接口。 1. 继承Thread类： 当一个类继承了Thread...
Java-Java快速入门教程
11-13
7. **多线程**：Java内置了对多线程的支持，通过Thread类和Runnable接口可以创建并管理多个执行线程，实现并发执行。 8. **Java标准库**：Java标准库（Java API）包含了大量的类和方法，涵盖了从基本的数据类型操作...
线程中yield的使用
qq_46173719的博客
06-06 574
yield yield可以让线程从运行状态变为就绪状态，但礼让不一定会成功，要看cpu去如何调度。 public class TestYield { public static void main(String[] args) { Yield yield = new Yield(); new Thread(yield,"a").start(); new Thread(yield,"b").start(); } } class Yield imp
深入理解多线程中的yield方法
m0_74117571的博客
06-14 1701
例如，在一个生产者-消费者模型中，当生产者生产完数据后，可以调用yield方法暂停自己的执行，让消费者线程有机会执行。yield方法是多线程编程中的一项重要技术，通过使用yield方法，我们可以实现线程的协作执行和提高线程的响应性。换句话说，yield方法可以将线程的执行权交给其他线程，从而实现线程的切换和调度。因此，在使用yield方法时，需要仔细考虑线程之间的依赖关系，确保不会出现死锁的情况。使用yield方法时，应该兼顾线程的公平性，避免某个线程长时间占用CPU资源而导致其他线程无法得到执行的情况。
Java线程基础(15): yield()、Sleep()
mingyuli的博客
07-20 1159
1、yield和sleep方法 Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入TIMED_WAITING状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。 Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的CPU时间片，但不释放锁资源，由运行状态变为就绪状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的
java多线程入门（很到位）
weixin_45131680的博客
01-13 412
java中之所以有多线程机制，目的就是为了提高程序的处理效率。 对于单核的CPU来说，不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做。
yield方法的用法
hello world
07-13 4177
让出cpu执行权的yield方法 Thread类中有一个静态的yield方法，当一个线程调用yield方法时，实际就是暗示线程调度器当前请求让出自己的cpu使用，但是线程调度器可以无条件忽略这个暗示。 操作系统为每一个线程分配一个时间片来占有cpu，正常情况下当一个线程把分配给自己的时间片用完之后，线程调度器才会进行下一轮的线程调度，而当一个线程调用了Thread类的静态方法yield时，是在告诉...
Java线程中yield()使用方法简介说明
qq_25073223的博客
10-24 1359
Java线程中yield()使用方法简介说明
JAVA基础-多线程入门（详解）
0
07-28 952
线程（Thread)是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。一个线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每个线程并行执行不同的任务。线程在Unix SystemV及SunOS中也被称为轻量进程（Lightweight Processes),但“轻量进程”更多指内核线程（Kernel Thread),而用户线程（User Thread)则被称为“线程”。
从零学Java 多线程(基础)
最新发布
哈哈哈哈丶昊的博客
01-15 969
进: 正在进行;程: 程序程序：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念；进程：进程是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位程序是静止的，只有真正运行时的程序，才被称为进程。目前操作系统都是支持多进程，可以同时执行多个进程，通过进程ID区分。概念: 线程，又称轻量级进程（Light Weight Process）。进程中的一个执行路径，同时也是CPU的基本调度单位。进程由多个线程组成，彼此间完成不同的工作，抢占式执行，称为多线程。
Java 多线程入门
jiaweilovemingming的博客
05-31 235
进程、线程和多线程 在说进程之前，先回顾一下什么是程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的过程。 进程：执行程序的一次过程，是动态的概念。是系统资源分配的单位。 线程：一个进程中可以包括多个线程（一个进程中最少包含一个线程）。线程是 CPU 执行和调度的单位。 假设我们正在观看一部电影，电影的播放就可以看做是一个进程。电影播放包括声音、图像、字幕等，这些可以看做是线程，如图所示 多线程：多线程分两种情况，多核和单核。 多核：即有多个 CPU，此时的多线程是真正的多线程
Java多线程入门：创建与实践
Java多线程入门是每个Java程序员必备的知识之一，它允许程序并发执行多个任务，提升程序性能和响应性。本文将深入探讨Java中的多线程概念，包括进程和线程的区别，以及如何在Java中实现多线程。 首先，理解进程和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值