JAVA-多线程知识点总结(二)

简介: JAVA-多线程知识点总结(二)

三、多线程的生命周期

3.1JDK5.0之前:五种状态

3.1JDK5.0之后:六种状态

四、线程安全问题及解决

1.概念

线程安全是多线程编程时的计算机程序代码中的一个概念。在拥有共享数据的多条线程并行执行的程序中,线程安全的代码会通过同步机制保证各个线程都可以正常且正确的执行,不会出现数据污染等意外情况。

2.出现的原因
-- 抢占式执行——罪魁祸首

CPU的调度方法为抢占式执行,随机调度,这个是导致线程安全问题的最根本的原因。但是这个原因我们无能为力,无法改变。

--多个线程同时修改同一个变量

当修改变量这个操作并非原子性的。这样在并发的环境下就很容易出现线程安全问题。这种情况可以通过代码结构来进行一定的规避,但是这种方法不是一个普适性特别高的方案。


--原子性

如果修改操作是原子性的,那么出现线程安全问题的概率还是比较低的。但如果是非原子的(++操作,其可以被拆分为load,add,save三个操作),那么出现问题的概率就非常高了。能够把修改行为变成原子操作,就是解决线程安全问题的关键方法!(synchronized关键字)

--内存可见性问题

内存可见性是指当一个线程修改了共享变量的值,其他线程能够立即感知这个修改。


如果一个线程读,一个线程改(这样的操作就可能引起内存可见性问题,也会出现线程安全问题)。此时前一个线程读取到的值,不一定是修改之后的值,即读线程没有感知到变量的变化——归根结底是编译器/JVM在多线程环境下优化时产生了误判。(volatile关键字)

--指令重排序

指令重排序是因为编译器对我们的代码进行了一些“自作主张”的优化,编译器会在保持逻辑不变的情况下。调整代码的顺序,从而加快代码的执行效率。这样也会出现线程安全问题。

4.线程的同步机制

synchronized解决了线程安全的问题,但在数据共享时多线程是串行执行,性能低。

synchronized 的使用方法:

1.修饰方法

1)修饰普通方法

锁对象是this,谁调用这个普通方法,锁的对象就是谁

2).修饰类方法

锁对象是类对象

2.修饰代码块

显式/手动指定锁对象.

3.可重入

一个线程针对同一个对象加锁两次,是否会有问题,如果没有问题,就叫可重入,如果有问题,就叫不可重入.

a.同步代码块

说明:

--需要被同步的代码,即为操作共享数据的代码。

--共享数据,即多个线程都需要操作的数据。

--需要被同步的代码,在被synchronized包裹以后,就使得一个线程在操作这些代码过程中,其他线程必须等待。


--同步监视器,俗称锁,哪个线程获取了锁,哪个线程就能执行需要被同步的代码


--同步监视器,可以使用任何一个类的对象充当。但是,多个线程必须共同用一个同步监视器。


注意: 在继承Thread类的方式中,同步监视器要慎用this,可以考虑使用:当前类.class。

        在实现Runnable接口的方式中,同步监视器可以考虑使用:this

//用Thread类
class Window extends Thread{
    private static int ticket=100;
   // private static Object object=new Object();
    @Override
    public void run() {
        while(true) {
       // synchronized (object){  
            synchronized (Window.class) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + 
                             ":售票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class synchronizedThread {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}
 
//用Runnable接口
class Window2 implements Runnable{
    private Integer ticket=100;
    @Override
    public void run() {
        while(true) {
            synchronized (this) {
 
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() +
                              ":售票,票号为:" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class synchronizedRunnable {
    public static void main(String[] args) {
        Window2 w = new Window2();
        new Thread(w,"窗口1").start();
        new Thread(w,"窗口2").start();
        new Thread(w,"窗口3").start();
    }
}
b.同步方法

说明:

--如果操作共享数据的代码完整的声明在了一个方法中,就称此方法为同步方法。

--非静态的同步方法,默认同步监视器是this

  静态的同步方法,默认同步监视器是当前类的本身。

(本文图片及内容来自尚硅谷视频,部分补充内容来自:原文链接

//用Runnable接口
class method2 implements Runnable{
    private Integer ticket=100;
    @Override
    public void run() {
        while(true){
            buy();
        }
    }
    public synchronized void buy(){  // 同步监视器为this  ,而且方法也不是static的
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + 
       ":售票,票号为:" + ticket);
            ticket--;
        }
    }
}
public class synchronizedRunnableMethod {
    public static void main(String[] args) {
        method2 m = new method2();
        new Thread(m,"窗口1").start();
        new Thread(m,"窗口2").start();
        new Thread(m,"窗口3").start();
    }
}
 
//用Thread类
class method extends Thread{
    private static Integer ticket=100;
    @Override
    public void run() {
        while(true){
            buy();
        }
    }
 
    // 因为是继承Thread,创建多个线程会创建method类的多个实例,必须声明为static
    public synchronized static void buy(){ // 同步监视器还是类对象本身  method.class
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + ":售票,票号为:" + ticket);
            ticket--;
        }
    }
}
public class synchronizedThreadMethod {
    public static void main(String[] args) {
        method m1 = new method();
        method m2 = new method();
        method m3 = new method();
        m1.setName("窗口1");
        m2.setName("窗口2");
        m3.setName("窗口3");
        m1.start();
        m2.start();
        m3.start();
    }
}
 
相关文章
|
13天前
|
Java 调度
Java线程的六种状态
Java线程有六种状态: 初始(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)、终止(TERMINATED)。
34 1
|
2天前
|
监控 Java
Java并发编程:深入理解线程池
在Java并发编程领域,线程池是提升应用性能和资源管理效率的关键工具。本文将深入探讨线程池的工作原理、核心参数配置以及使用场景,通过具体案例展示如何有效利用线程池优化多线程应用的性能。
|
5天前
|
安全 算法 Java
Java 中的并发控制:锁与线程安全
在 Java 的并发编程领域,理解并正确使用锁机制是实现线程安全的关键。本文深入探讨了 Java 中各种锁的概念、用途以及它们如何帮助开发者管理并发状态。从内置的同步关键字到显式的 Lock 接口,再到原子变量和并发集合,本文旨在为读者提供一个全面的锁和线程安全的知识框架。通过具体示例和最佳实践,我们展示了如何在多线程环境中保持数据的一致性和完整性,同时避免常见的并发问题,如死锁和竞态条件。无论你是 Java 并发编程的新手还是有经验的开发者,这篇文章都将帮助你更好地理解和应用 Java 的并发控制机制。
|
10天前
|
安全 Java 开发者
Java并发编程中的线程安全性与性能优化
在Java编程中,处理并发问题是至关重要的。本文探讨了Java中线程安全性的概念及其在性能优化中的重要性。通过深入分析多线程环境下的共享资源访问问题,结合常见的并发控制手段和性能优化技巧,帮助开发者更好地理解和应对Java程序中的并发挑战。 【7月更文挑战第14天】
|
10天前
|
监控 Java API
Java并发编程之线程池深度解析
【7月更文挑战第14天】在Java并发编程领域,线程池是提升性能、管理资源的关键工具。本文将深入探讨线程池的核心概念、内部工作原理以及如何有效使用线程池来处理并发任务,旨在为读者提供一套完整的线程池使用和优化策略。
|
13天前
|
缓存 安全 Java
Java中线程池如何管理?
【7月更文挑战第11天】Java中线程池如何管理?
21 2
|
13天前
|
存储 安全 算法
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第72天】 在现代软件开发中,尤其是Java应用开发领域,并发编程是一个无法回避的重要话题。随着多核处理器的普及,合理利用并发机制对于提高软件性能、响应速度和资源利用率具有重要意义。本文旨在探讨Java并发编程的核心概念、线程安全的策略以及性能优化技巧,帮助开发者构建高效且可靠的并发应用。通过实例分析和理论阐述,我们将揭示在高并发环境下如何平衡线程安全与系统性能之间的关系,并提出一系列最佳实践方法。
|
12天前
|
Java 调度
java中线程的6种状态
java中线程的6种状态
|
12天前
|
算法 Java 开发者
Java中的多线程编程技巧与实践
在现代软件开发中,多线程编程成为提升应用程序性能和响应能力的关键技术之一。本文将深入探讨Java语言中多线程编程的基础概念、常见问题及其解决方案,帮助开发者更好地理解和应用多线程技术。 【7月更文挑战第12天】
15 0
|
12天前
|
Java 大数据 API
Java语言的核心知识点与特性
Java 是一种广泛使用的编程语言,自 1995 年发布以来,它已经成为了企业级应用开发、移动应用开发、大数据处理和云计算等领域的主流技术。
20 0