Java基础之多线程

最新推荐文章于 2024-09-08 10:40:56 发布
最新推荐文章于 2024-09-08 10:40:56 发布
阅读量437 收藏
点赞数 1
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42646178/article/details/123986744
版权

1.多线程的创建方式

  1. Thread创建
  2. Runnable创建
  3. Lambda表达式创建
  4. Callable和 Future创建线程
  5. 使用线程池创建
package com.zw.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class CreateThread {

  public static void main(String[] args) throws InterruptedException, ExecutionException {
    new ThreadClass().start(); // 1.Thread创建
    new Thread(new RunnableClass()).start(); // 2.Runnable创建
    new Thread(() -> { // 3.Lambda表达式创建
      System.out.println("Lambda is run...");
    }).start();;
    // 4.Callable和 Future创建线程
    // Runnable的缺点：
    // 1.  run没有返回值
    // 2.  不能抛异常
    CallableThread callableThread = new CallableThread();
    FutureTask<String> task = new FutureTask<String>(callableThread);
    new Thread(task).start();
    // 获取返回结果
    String result = task.get();
    System.out.println("Callable's result is " + result);
    // 5.使用线程池创建
    ExecutorService executorService = Executors.newCachedThreadPool();
    executorService.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println("线程池创建...");
        }
    });
  }

}

class ThreadClass extends Thread {
  @Override
  public void run() {
    System.out.println("ThreadClass is run...");
  }
}

class RunnableClass implements Runnable {
  @Override
  public void run() {
    System.out.println("RunnableClass is run...");
  }
}

class CallableThread implements Callable<String> {
  @Override
  public String call() throws Exception {
    System.out.println("CallableThread is run...");
    return "success";
  }
  
}

ThreadClass is run...
RunnableClass is run...
Lambda is run...
CallableThread is run...
Callable's result is success
线程池创建...

2.Thread中的常用的方法

package com.zw.thread;

public class ThreadMethods {

  public static void main(String[] args) throws InterruptedException {
    Thread test1 = new Thread(() -> {
      // 1.获得当前线程 Thread.currentThread()
      System.out.println(Thread.currentThread().getName()); // test1 getName()返回线程名称
      // 3.让当前线程休眠指定的毫秒数
      try {
        Thread.sleep(1000); // 休眠一秒
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      // 4.放弃当前的cpu资源 转为就绪状态
      System.out.println("放弃当前的cpu资源");
      Thread.yield();
      try {
        Thread.sleep(1000); // 休眠一秒
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      System.out.println("重新获取cpu资源"); // 重新获取cpu资源

    }, "test1");
    // 2.isAlive() 判断当前线程是否处于活动状态
    System.out.println(test1.isAlive()); // false
    test1.start();
    System.out.println(test1.isAlive()); // true

    Thread.sleep(1000);
    // 5.放弃当前的cpu资源，主线程拿到资源
    System.out.println("主线程拿到资源"); // 主线程拿到资源
    
    // 6.setPriority() 设置线程的优先级别，优先级别越高越容易，不能保证优先级高的线程先运行
    
    // 7.interrupt() 中断线程 我们可以interrupted()判断来手动停止 比如break return
    System.out.println(test1.interrupted()); // false
    // test1.interrupt(); // 会报错 因为interrupt()方法只能中断阻塞过程中的线程而不能中断正在运行过程中的线程。
    
    // 8.守护线程 线程分为用户线程与守护线程
    // 守护线程是为其他线程提供服务的线程，如垃圾回收(GC)就是一个典型的守护线程。
    // 守护线程不能单独运行，当jvm中没有其他用户线程，只有守护线程时，守护线程会自动销毁，jvm会自动退出。
    Thread test2 = new Thread(() -> {
      System.out.println("守护线程开启");
    }, "test1");
    test2.setDaemon(true);
    test2.start();
  }

}

3.多线程的状态

  1. 新建状态
  2. 就绪状态，拿到cpu资源就可以执行
  3. 运行状态，拿到了cpu资源开始执行程序
  4. 阻塞状态，处于运行状态的线程因为某种原因放弃cpu资源进入阻塞状态
  5. 终止状态，运行完了自动进入

阻塞状态分为三种：

  1. 等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，
  2. 同步阻塞：运行的线程访问的资源被加了锁，JVM会把该线程放入“锁池”中
  3. 其它阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

在这里插入图片描述

4.线程安全问题

多线程虽然提高了程序的效率，但是当多个线程对同一个资源进行访问的时候会带来线程同步的问题，
主要有以下的问题。

4.1原子性

不可分割的操作单位，对于一个资源的改变要么全部执行，要么全部不执行。

int i = 0; // 原子操作
int j = i ++; //不是原子操作 因为分为两步 i = i + 1, j = i

保持原子性我们可以有两种方法：

  1. 加锁，保证同一时刻只有一个线程访问
  2. CAS指令 ：直接在硬件层次上实现，看做是一个硬件锁。

4.2可见性

对一个共享变量进行修改后其它的线程没能够及时获取到更新的值。

4.3有序性

在多核处理器的环境下，编写的顺序结构，这种操作执行的顺序可能是没有保障的：
编译器可能会改变两个程序的先后顺序；
处理器也可能不会按照目标代码的顺序执行；

5.解决多线程安全问题 线程同步

案例：

package com.zw.thread;

public class ThreadQuestion {

  public static void main(String[] args) {
    ThreadRunnable tRunnable = new ThreadRunnable();
    new Thread(tRunnable, "线程1").start();
    new Thread(tRunnable, "线程2").start();
  }

}

class ThreadRunnable implements Runnable {
  private int i = 100;

  @Override
  public void run() {
    while (true) {
      if (i <= -1) break;
      i --;
      System.out.println(Thread.currentThread().getName() + ": i = " + i);
    }
  }
}

线程2: i = 5
线程2: i = 4
线程2: i = 3
线程2: i = 2
线程2: i = 1
线程2: i = 0
线程2: i = -1
线程1: i = 6

当多个线程访问统一资源，出现了线程安全的问题。为了使得线程同步，有以下方法解决。

5.1 加锁

锁的作用： 锁可以实现对共享数据的安全访问，保障线程的原子性，可见性，与有序性。

5.1.1 synchronized

内部锁：synchronized可以加在代码块或者方法上。这种锁是一种排他锁

package com.zw.thread;

public class ThreadQuestion {

  public static void main(String[] args) {
    ThreadRunnable tRunnable = new ThreadRunnable();
    new Thread(tRunnable, "线程1").start();
    new Thread(tRunnable, "线程2").start();

  }

}

class ThreadRunnable implements Runnable {
  private int i = 100;

  @Override
  public void run() {
    synchronized (this) {
      while (true) {
        if (i <= 0) break;
        i --;
        if (i == 66) {
          System.out.println(Thread.currentThread().getName() + ": i = " + i);
          break;
        }
        System.out.println(Thread.currentThread().getName() + ": i = " + i);
      }
    }
  }
}

线程2: i = 9
线程2: i = 8
线程2: i = 7
线程2: i = 6
线程2: i = 5
线程2: i = 4
线程2: i = 3
线程2: i = 2
线程2: i = 1
线程2: i = 0

synchronized无论是正常结束还是抛出异常后，都会释放锁，而lock必须手动释放锁才可以。

5.1.2 显示锁Lock

和synchronized的区别：

  1. 如果临界区是只读操作，其实可以多线程一起执行，但使用synchronized的话，同一时间只能有一个线程执行。
  2. synchronized无法知道线程有没有成功获取到锁
    公平锁与非公平锁
    其实通俗意义来说就是“先来后到”。如果对一个锁来说，先对锁获取请求的线程一定会先被满足，后对锁获取请求的线程后被满足，那这个锁就是公平的。反之，那就是不公平的。

ReentrantLock支持非公平锁和公平锁两种。（可以根据构造方法的重载选择不同的锁）。

public class ThreadQuestion {

  public static void main(String[] args) {
    RockTest rockTest = new RockTest();
    new Thread(rockTest, "线程1").start();
    new Thread(rockTest, "线程2").start();
  }
}

class RockTest implements Runnable {
  private int i = 100;
  //首先定义一个显示锁
  private Lock lock = new ReentrantLock();
  
  @Override
  public void run() {
    lock.lock(); // 获得锁
    while (true) {
      if (i <= 0) break;
      i --;
      if (i == 66) {
        System.out.println(Thread.currentThread().getName() + ": i = " + i);
        break;
      }
      System.out.println(Thread.currentThread().getName() + ": i = " + i);
    }
    lock.unlock(); // 释放锁
  }
  
}

ReadWriteLock读写锁可以在同一时刻允许多个读线程访问，而读写锁可以在同一时刻允许多个读线程访问。Java提供了ReentrantReadWriteLock类作为读写锁的默认实现，内部维护了两个锁：一个读锁，一个写锁。通过分离读锁和写锁，使得在“读多写少”的环境下，大大地提高了性能。

5.1.3 volatile

volatile可以保证内存可见性且禁止重排序
可以强制线程从公共内存中读取变量的值，而不是从工作内存中读取。

package com.zw.thread;

public class VolatileTest {
  private volatile boolean flag = true;
  
  public static void main(String[] args) {
    VolatileTest test = new VolatileTest();
    new Thread(() -> {
      while(test.flag) {
        System.out.println(Thread.currentThread().getName() + ": 正在执行" );
      }
    }, "线程1").start();
    
    new Thread(() -> {
      test.flag = false;
      System.out.println(Thread.currentThread().getName() + ": 修改完了" );
    }, "线程2").start();
  }

}

线程1: 正在执行
线程2: 修改完了

而如果flag变量没有用volatile修饰，在main中修改的标志就不会更新到主内存。volatile保证了变量的可见性但是不能保证原子性。

5.2 死锁的问题

当两个或两个以上的线程在执行过程中，因为争夺资源而造成的一种相互等待的状态，由于存在一种环路的锁依赖关系而永远地等待下去，如果没有外部干涉，他们将永远等待下去，此时的这个状态称之为死锁。
在线程A持有锁L并想获得锁M的同时，线程B持有锁M并尝试获得锁L，那么这两个线程将永远地等待下去，这种情况就是死锁形式
死锁的四个必要条件：

  1. 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用完释放。
  2. 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对自己已获得的其它资源保持不放。
  3. 不剥夺条件：指进程已获得的资源，在未使用完之前，不能被剥夺，只能在使用完时由自己释放。
  4. 循环等待条件：第一个线程等待其他线程，后者又在等待第一个线程。
package com.zw.thread;

public class DeadLock {

  public static void main(String[] args) {

    final StringBuffer s1 = new StringBuffer();
    final StringBuffer s2 = new StringBuffer();

    new Thread() {
      @Override
      public void run() {
        // 先拿锁一，再拿锁二
        synchronized (s1) {
          s1.append("a");
          s2.append("1");

          try {
            Thread.sleep(500);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          synchronized (s2) {
            s1.append("b");
            s2.append("2");

            System.out.println(s1);
            System.out.println(s2);
          }
        }
      }
    }.start();

    // 上面线程1拿到了锁一让它睡眠使得线程2拿到锁二，这时候锁一在线程1，
    // 线程2拿不到锁一，线程1拿不到锁二，互相等待造成死锁
    new Thread(new Runnable() {
      @Override
      public void run() {
        synchronized (s2) {
          s1.append("c");
          s2.append("3");

          synchronized (s1) {
            s1.append("d");
            s2.append("4");

            System.out.println(s1);
            System.out.println(s2);
          }
        }
      }
    }).start();
  }
}

破坏四个必要条件中的一个就可以阻止死锁问题。

步入飞花
关注
专栏目录
线程创建的三种方式
小陈学java
04-01 353
1.new 一个类，但是这个类需要继承Thread,并且重写thread里面的run方法。 public class CustomThread extends Thread { //run是线程真正执行的任务 @Override public void run() { for (int i = 0; i <10 ; i++) { System.out.println(i); } } } 缺点：因为每个类都只
java创建线程的方式
qq_38785977的博客
05-17 500
java创建线程的方式 方法一：直接使用Thread // 创建线程对象 Thread t = new Thread() { public void run() { // 要执行的任务 } }; // 启动线程 t.start(); 例如： public static void main(String[] args) { Thread t1 = new Thread("t1") { @Override // run 方法内实现了要执行
Java新建一个线程的几种方法
qq_42173611的博客
09-22 433
Java创建一个线程的几种方法
【Java多线程】【Thread类及常见方法】
OTO233的博客
07-19 788
Thread类是 JVM用来管理线程的一个类，每个线程都有一个唯一的相关联的Thread对象；每个执行流需要一个对象描述，就是Thread类的对象，JVM讲这些Thread对象组织起来，用于线程调度，线程管理；
JAVA Thread类的基本用法
qq_63525426的博客
03-15 589
java标准库中Thread类对操作系统提供的API进行了进一步的抽象和封装。
Java基础之多线程.md
11-10
Java多线程，Java基础，并发
Java基础多线程.xmind
09-20
个人关于java基础多线程的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。
JAVA零基础到高级进阶特训营 JAVA多线程并发设计+Spring高级+数据库开发+JAVA基础等
08-04
这套课程既可以作为从零基础开始...课程的主要内容涉及有JAVA基础课程、JAVA多线程与并发编程、数据库开发基础和进阶、Spring Framework、Spring进阶、Spring MVC框架、Spring boot、Java常用类库、Java异常处理等等
JAVA之多线程（基础图）
02-20
JAVA之多线程（基础图）
java new thread()_(一)java多线程之Thread
weixin_39619478的博客
02-16 6344
Thread类学习java线程的开发者,首先遇到的第一个类就是Thread,通过使用Thread类,我们就可以启动,停止,中断一个线程. 在同一个时间片里, 可能会有多个线程在执行, 每个线程都拥有它自己的方法调用堆栈, 参数和变量.每个app至少会有一个线程--主线程(main thread).创建一个线程java创建线程有两种方式创建一个继承Thread的子类,并实现run方法使用Thread...
184_刘发顺_Java核心编程
m0_65768759的博客
11-11 311
无
Thread、线程状态转化、方法使用
蓝色的青春_巍
06-17 1321
Thread、线程状态转化、方法使用一、Thread状态关系二、状态测试三、Thread方法使用四、总结 一、Thread状态关系 java 的线程的状态在Thread.state的枚举类中 public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 这五种状态的描述了一个线程的生命周期，其他状态的定
线程（1）
weixin_60475929的博客
01-25 433
线程 线程（thread）是一个程序内部的一条执行路径 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径 程序中只有一条执行路径，那么这个程序就是单线程的程序 多线程 概述 多线程是指从软硬件上实现多条执行流程的技术 多线程的作用 多线程的创建 方式一：继承Thread类 Thread类： Java是通过java.lang.Thread类来代表线程 按照面向对象的思想，Thread类应该提供多线程的方式 方案： 缺点； 线程类已...
new Thread(()-＞{ xxx.xxx }).start()；的作用
weixin_60170500的博客
09-12 982
该代码是Java中的一段匿名内部类的使用，用于创建一个新的线程并启动它。具体来说，'new Thread(()->{})' 创建了一个新的线程，并且这个线程的任务是执行括号中的Lambda表达式。所以这个新线程实际上执行了xxx.xxx的任务。'start()'方法则是启动这个新创建的线程。
9中单例模式（优点，缺点，区别，及应用场景）
lzp3033的博客
04-11 239
/* 简介 确保某一个类只有一个对象，而且自行实例化并向系统提供这个实例 这个类称为单例类，它提供全局访问的方法。 单例模式是一种对象创建型模式 基本的实现思路 单例模式要求类能够有返回对象一个引用(永远是同一个)和一个获得该实例的方法 1，私有化该类构造方法。 2，通过new在本类中创建一个本类对象。 3，定义一个公有的方法，将创建的对象返回。 注意事项 单例模式在多线程的应用场合下必须...
spring事务详细讲解-深入浅出
最新发布
小电玩
09-08 539
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java基础：多线程原理与创建方法详解
Java基础之多线程是计算机编程中的核心概念，尤其是在并发编程领域，它允许程序同时执行多个任务或操作，从而提高系统的效率和响应能力。本文将深入探讨Java中的多线程实现以及其重要性。 **1. 线程简介** 多线程是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值