Java线程技术总结

最新推荐文章于 2023-07-27 19:07:59 发布
置顶 最新推荐文章于 2023-07-27 19:07:59 发布
阅读量1.2k 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijiuhuizanping/article/details/117920083
版权

多线程创建方式:

1.继承thread

通过继承 Thread 类来创建线程的一般步骤如下：

  1. 定义一个 Thread 类的子类，重写 run() 方法，将相关逻辑实现，run() 方法就是线程要执行的业务逻辑方法；
  2. 创建自定义的线程子类对象；
  3. 调用子类实例的 start() 方法来启动线程。
public class MyThread extends Thread{ 
@Override
public void run() { 
System.out.println(Thread.currentThread().getName()); 
    }
}
public class MyThreadTest { 
public static void main(String[] args) { 
    // 创建线程
     MyThread thread = new MyThread(); 
    // 启动线程 
    thread.start(); 
    }
}

 

2. 实现 Runnable 接口

通过实现 Runnable 接口创建线程一般步骤如下：

  1. 定义 Runnable 接口实现类 MyRunnable，并重写 run() 方法；
  2. 创建 MyRunnable 实例 runnable，以 runnable 作为 target 创建 Thead 对象，该 Thread 对象才是真正的线程对象；
  3. 调用线程对象的 start() 方法。

实现runnable接口与继承thread相比有一下优势:

1.实现Runnable通过创建任务，然后给线程分配的方式来实现多线程，更适合多个线程同时执行相同的情况。

2.可以避免但继承所带来的局限性

3.任务与多线程本身是分离的，提高了程序的健壮性

4.线程池技术，接受runnable类型的任务，不接受thread类型的线程

public class MyRunnable implements Runnable{
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName()); 
    }
}


public static void main(String[] args) {
    //实现Runnable
    //1.创建一个任务对象
    MyRunnable r = new MyRunnable();
    //2.创建一个线程，并为其分配一个任务
    Thread t = new Thread(r);
    //3.执行这个线程
    t.start();
}

3.线程中断

以前的stop方法现在已经弃用，因为stop可能造成线程结束而资源没有释放的问题。

一个线程是一个独立的执行路径，他是否应该结束，应该由其自身决定。

通常给线程添加中断标记，(wait,sleep,interrupt)等标记。调用线程.interrupt，然后在要结束的地方添加return。

如果发现异常，就在异常的地方添加异常(catch块)即可。

4.守护线程

守护线程:用于守护用户线程的，当最后一个用户线程结束时，所有守护线程自动死亡。

线程分为:守护线程和用户线程

用户线程:当一个进程不包含任何的存活的用户线程时，进程结束

Thread t = new Thread(new MyRunnable);
//设置为守护线程
t.setDaemon(true);
t.start();

上面代码当主线程结束时，t线程即使没有结束，也会跟着死亡。

5.线程安全问题

public class Democracy {
    public static void main(String[] args) {
        //线程不安全
        Runnable run = new Ticket();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();
    }
    static class Ticket implements Runnable{
        //票数
        private int count = 10;

        @Override
        public void run() {
            while(count > 0) {
                //卖票
                System.out.println("正在准备卖票");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count--;
                System.out.println("出票成功，余票:" + count);
            }

        }
    }
}

运行结果:

正在准备卖票
正在准备卖票
正在准备卖票
出票成功，余票:7
正在准备卖票
出票成功，余票:7
正在准备卖票
出票成功，余票:7
正在准备卖票
出票成功，余票:6
正在准备卖票
出票成功，余票:4
正在准备卖票
出票成功，余票:5
正在准备卖票
出票成功，余票:3
正在准备卖票
出票成功，余票:2
正在准备卖票
出票成功，余票:1
正在准备卖票
出票成功，余票:0
出票成功，余票:-1
出票成功，余票:-2

可以看到出现卖票是-2的情况，这是因为在count为1的情况下，三个线程都进入循环，这时count还没有变化，从而出现上述问题。

5.1  线程安全1-同步代码块

格式: synchronized(锁对象) { }

Java中任何对象都可以作为锁对象

注意:线程必须抢占同一把锁，才能实现线程排队，否则无法实现

 

 

5.2  线程安全2-同步方法

 

5.3  线程安全3-显式锁Lock

同步代码块和同步方法都属于隐式锁

显式锁，自己创建，自己解锁。通过lock()和unlock()实现上锁和解锁

 

6. 公平锁与非公平锁

ReentrantLock 的公平锁

ReentrantLock 默认采用非公平锁，除非在构造方法中传入参数 true 。

//默认
public ReentrantLock() {
    sync = new NonfairSync();
}
//传入true or false
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

公平锁的 lock 方法：

static final class FairSync extends Sync {
    final void lock() {
        acquire(1);
    }
    // AbstractQueuedSynchronizer.acquire(int arg)
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            // 1. 和非公平锁相比，这里多了一个判断：是否有线程在等待
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }
}

根据!hasQueuedPredecessors()条件，意思是说当前同步队列没有前驱节点（也就是没有线程在等待）时才会去compareAndSetState(0, acquires)使用CAS修改同步状态变量。所以就实现了公平锁，根据线程发出请求的顺序获取锁。

非公平锁的lock方法

static final class NonfairSync extends Sync {
    final void lock() {
        // 2. 和公平锁相比，这里会直接先进行一次CAS，成功就返回了
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
    // AbstractQueuedSynchronizer.acquire(int arg)
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}
/**
 * Performs non-fair tryLock.  tryAcquire is implemented in
 * subclasses, but both need nonfair try for trylock method.
 */
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //3.这里也是直接CAS，没有判断前面是否还有节点。
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

而在nonfairTryAcquire方法中并没有判断是否有前驱节点在等待，直接CAS尝试获取锁，如注释3。由此实现了非公平锁。

非公平锁和公平锁的两处不同： 1. 非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。

非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排到后面。

公平锁和非公平锁就这两点区别，如果这两次 CAS 都不成功，那么后面非公平锁和公平锁是一样的，都要进入到阻塞队列等待唤醒。

相对来说，非公平锁会有更好的性能，因为它的吞吐量比较大。当然，非公平锁让获取锁的时间变得更加不确定，可能会导致在阻塞队列中的线程长期处于饥饿状态。

 

7.线程死锁

死锁的概念：
在两个或多个并发进程中，如果每个进程持有某种资源而又都等待别的进程释放它或它们现在保持着的资源，在未改变这种状态之前都不能向前推进，称这一组进程产生了死锁
通俗地讲，就是两个或多个进程被无限期地阻塞、相互等待的一种状态

死锁产生的原因主要是：
　　 1.系统资源不足
　　 2.进程推进顺序非法

产生死锁的必要条件：
　　（1）互斥（mutualexclusion），一个资源每次只能被一个进程使用
　　（2）不可抢占（nopreemption），进程已获得的资源，在未使用完之前，不能强行剥夺
　　（3）占有并等待（hold andwait），一个进程因请求资源而阻塞时，对已获得的资源保持不放
　　（4）环形等待（circularwait），若干进程之间形成一种首尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

死锁的解除与预防：
　　理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和解除死锁。
　　在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确定资源的合理分配算法，避免进程永久占据系统资源。
　　此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。

死锁的处理策略：鸵鸟策略、预防策略、避免策略、检测与恢复策略

8.多线程通信问题

也叫生产者和消费者问题，往期已经介绍过

package Test;

public class Demo {
    /**
     * @Description: 多线程通信问题，生产者和消费者问题
     * @Author: Mr.Li
     * @Date: 2021/06/15
     */
    public static void main(String[] args) {
        Food f = new Food();
        new Cook(f).start();
        new Waiter(f).start();
    }
    //厨师
    static class Cook extends Thread{
        private Food f;
        public Cook(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                if (i%2 == 0) {
                    f.setNameAndTaste("鱼香肉丝","酸辣味");
                } else {
                    f.setNameAndTaste("回锅肉","香甜味");
                }
            }
        }
    }
    //服务生
    static class Waiter extends Thread{
        private Food f;
        public Waiter(Food f) {
            this.f = f;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                f.get();
            }
        }
    }
    //食物
    static class Food{
        private String name;
        private String taste;
        //true表示可以生产
        private boolean flag = true;
        public synchronized  void setNameAndTaste(String name,String taste){
            if (flag) {
                this.name = name;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.taste = taste;
                //生产完毕后，更改为false
                flag = false;
                //唤醒在当前this
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
        public synchronized void get() {
            if (!flag) {
                System.out.println("服务员端走的菜的名称是:" + name + ",味道:" + taste);
                flag = true;
                this.notifyAll();
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

运行结果:

服务员端走的菜的名称是:鱼香肉丝,味道:酸辣味
服务员端走的菜的名称是:回锅肉,味道:香甜味
服务员端走的菜的名称是:鱼香肉丝,味道:酸辣味
服务员端走的菜的名称是:回锅肉,味道:香甜味
服务员端走的菜的名称是:鱼香肉丝,味道:酸辣味
服务员端走的菜的名称是:回锅肉,味道:香甜味
服务员端走的菜的名称是:鱼香肉丝,味道:酸辣味
服务员端走的菜的名称是:回锅肉,味道:香甜味
服务员端走的菜的名称是:鱼香肉丝,味道:酸辣味
服务员端走的菜的名称是:回锅肉,味道:香甜味

 

9. Callable接口

Callable需要实现call（）方法。Callable可以返回值。

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

 

Callable使用步骤：

1. 编写类实现Callable接口 , 实现call方法
　class XXX implements Callable<T> {
　　@Override
　　public <T> call() throws Exception {
　　return T;
　　}
　}
2. 创建FutureTask对象 , 并传入第一步编写的Callable类对象
　FutureTask<Integer> future = new FutureTask<>(callable);
3. 通过Thread,启动线程
　new Thread(future).start();
 

10. 线程池

Java通过Executors提供四种线程池，分别为：

  • newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
  • newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  • newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
  • newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

 

分别代码显示：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 缓存线程池.
 * (长度无限制)
 * 执行流程:
 * 1. 判断线程池是否存在空闲线程
 * 2. 存在则使用
 * 3. 不存在,则创建线程 并放入线程池, 然后使用
 */
public class Test{
    ExecutorService service= Executors.newCachedThreadPool();
        //向线程池中 加入 新的任务
        service.execute(new Runnable(){
            @Override
            public void run(){
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable(){
            @Override
            public void run(){
               System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable(){
            @Override
            public void run(){
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
}

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test{ 
 /* 1. 判断线程池是否存在空闲线程
* 2. 存在则使用
* 3. 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
* 4. 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
*/
    ExecutorService service = Executors.newFixedThreadPool(2);
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程的名称:"+Thread.currentThread().getName());
            }
        });
}

 

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
    //效果与定长线程池 创建时传入数值1 效果一致.
    /**
     * 单线程线程池.
     * 执行流程:
     * 1. 判断线程池 的那个线程 是否空闲
     * 2. 空闲则使用
     * 4. 不空闲,则等待 池中的单个线程空闲后 使用
     */
    ExecutorService service = Executors.newSingleThreadExecutor();
        service.execute(new
            Runnable() {
                @Override
                public void run () {
                    System.out.println("线程的名称:" + Thread.currentThread().getName());
                 }
            });
        service.execute(new
            Runnable() {
                @Override
                public void run () {
                    System.out.println("线程的名称:" + Thread.currentThread().getName());
                }
            });
}

 

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

 

 

crazy-coding
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA多线程详解（超详细）
m0_74823434的博客
10-10 1万+
程序：开发写的代码称之为程序。程序就是一堆代码，一组数据和指令集，是一个静态的概念。进程(Process)：将程序运行起来，我们称之为进程。进程是执行程序的一次执行过程，它是动态的概念。进程存在生命周期，也就是说程序随着程序的终止而销毁。进程之间是通过TCP/IP端口实现交互的。线程(Thread)：线程是进程中的实际运作的单位，是进程的一条流水线，是程序的实际执行者，是最小的执行单位。通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程。线程是CPU调度和执行的最小单位。注意。
java多线程核心技术
01-19
资深Java专家10年经验总结，全程案例式讲解，首本全面介绍Java多线程编程技术的专著 结合大量实例，全面讲解Java多线程编程中的...要学习这些热点技术，Java多线程技术避无可避。而本书将引领读者拿下该“技术高地”。
多线程编程的精华：探索 Java 中的多种线程开启方式
聽海的聲音
12-19 873
聊到多线程,我们优先谈一下什么是进程?什么又是线程呢?教科书式的说法是:进程是计算机操作系统进行内存分配的最小单元;线程是计算机操作系统进行任务分配的最小单元 咱们用一个小故事,讲一下什么是线程?什么是进程? 我们可以将你们村比作一个操作系统,每家每户都可以比作一个应用程序,村长家比作QQ,二狗家比作360,胖丫家比作Office 这样我们就可以理解为:每家每户其实是运行在操作系统中的程序,这里的每个程序都是单独的一个进程,每个进程相互之间都...
java多线程（超详细）
热门推荐
zdl66的博客
08-14 9万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
Java多线程技术详解（全都是细节！）
qq_51070724的博客
11-22 557
详解Java多线程的多线程启动，线程标识，线程状态，sleep()与yield（）方法，线程优先级，守护线程，全是细节！详解多线程中常出现的异常等！
【Java 基础篇】Java多线程编程详解
繁依Fanyi的博客
06-26 2047
本文详细介绍了Java多线程编程的概念、原理和常用技术。多线程编程可以提高程序的性能和响应能力，但也需要注意线程安全和线程同步的问题。在实际开发中，合理地使用多线程可以充分发挥多核处理器的优势，提高程序的并发能力和执行效率。同时，需要注意避免多线程之间的竞争条件和数据一致性问题，保证线程的安全性和正确性。希望本文对你理解和应用Java多线程编程有所帮助！
Java多线程核心技术讲解
11-27
Java多线程核心技术：理解多线程、在Java中实现多线程、线程的生命周期、线程的优先级、线程的同步、线程的阻塞、守护线程、线程组、线程池、总结。
java多线程技术整理
08-21
看完了java多线程编程核心技术一书，总结
java线程安全总结.pdf
01-11
java线程安全总结.pdf
java线程学习总结.pdf
11-02
java线程学习总结.pdf
一篇搞懂Java多线程（全网最细）
让优秀成为一种习惯！
07-22 7898
Java多线程是一种强大而有趣的编程概念。它允许程序同时执行多个任务，就像一个宏大的交响乐团。每个线程都是一个独立的执行路径，有自己的速度和优先级。那么，我们期待多线程能给我们带来什么呢？
JAVA多线程
最新发布
weixin_45812603的博客
07-27 323
/线程的三种启动方式 public static void main(String [ ] args) {//1.方式1 继承Thread启动线程 Mythread mythread = new Mythread();//2.方式2 实现 Runable接口启动 Mytask mytask = new Mytask();//3.方式3 匿名内部类启动 与方式2本质上相同只是简洁写法 但是可读性差 new Thread(new Runnable() {i < 10;i ++) {
JAVA 多线程
m0_72527474的博客
05-07 155
创建状态，阻塞状态，死亡装填，就绪状态运行状态} } // 1. 继承Thread类 class MyThread1 extends Thread {} } // 2. 实现Runnable接口 class MyThread2 implements Runnable {} } // 3. 实现Callable接口 class MyThread3 implements Callable < Integer > {return 100;} }
Java多线程
王梦杰_MengJie
04-24 480
线程同步是Java多线程编程中不可或缺的一个知识点。在多个线程同时访问共享数据时，如果不进行线程同步，就会出现数据不一致的问题。Java提供了锁机制和同步机制来实现线程同步。使用锁机制可以简单地将方法或代码块锁定，确保同一时刻只有一个线程可以访问。而同步机制则可以通过wait()、notify()和notifyAll()三个方法来实现线程的等待和唤醒，从而保证线程同步。在使用线程同步时，需要注意线程安全和死锁等问题。
Java之多线程（一）—技术简介
qq_37080455的博客
07-12 356
进程（process）：是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 例如上图所示，当通过windows打开任务管理时，你所有正在使用的软件都会对应一个进程。无论是看不到的，还是看的到的程序，都会有一个进程。 现在操纵系统在运行一个程序时，比如：在Wind
Java多线程（超详解）
m0_52896041的博客
10-26 1万+
Java多线程（超详解）
Java自学基础 多线程
real_rookie的博客
11-05 381
Java多线程前言一、基本概念：程序、进程、线程使用多线程的优点何时需要多线程二、线程的创建和使用线程的创建和启动Thread类API中创建线程的两种方式继承方式和实现方式的联系与区别Thread类的有关方法线程的优先级三、线程的生命周期四、线程的同步Synchronized的使用方法同步机制中的锁同步的范围释放锁的操作不会释放锁的操作单例设计模式之懒汉式(线程安全)线程的死锁问题Lock(锁)synchronized 与 Lock 的对比总结 前言 一、基本概念：程序、进程、线程 程序(progra
java中实现多线程的三种方式
Mao_yafeng的博客
07-31 1万+
实现多线程的方法
帮我写一份java线程编程实验的实验小结
06-03
好的，以下是一份Java线程编程实验的实验小结。 #### 实验目的 本次实验主要目的是通过编写Java程序，了解多线程编程的基本概念和使用方法，掌握线程的创建、同步、通信等技术。 #### 实验内容 本次实验的主要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值