java线程的一路向北

最新推荐文章于 2020-05-13 11:47:23 发布
最新推荐文章于 2020-05-13 11:47:23 发布
阅读量99 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41562587/article/details/103942046
版权

  • 线程状态图：

  1. New状态：新建状态  【new 一个Thread 或者 new 一个Thread子类对象】
  2. Runable状态： 运行状态 【多个线程抢占CPU资源，谁抢到CPU资源，该线程则为运行状态，未抢到CPU资源的线程则为阻塞状态】【运行状态中的线程调用 wait()方法，则该线程将会进入永久等待状态，调用notify()方法，如果CPU空闲则会进入运行状态，否则进入阻塞状态】
  3. Block状态： 阻塞状态 【多个线程抢占CPU资源，谁抢到CPU资源，该线程则为运行状态，未抢到CPU资源的线程则为阻塞状态】
  4. Terminated状态：死亡状态 【线程执行完run()方法或调用stop()方法后或者线程中产生了异常】
  5. Timed_Waiting状态：休眠状态/计时等待  【线程调用sleep(long)方法或者wait(long)方法】【休眠状态结束  如果CPU被占用，那么该线程则成为阻塞状态】
  6. Waiting状态：永久等待状态 【线程执行】 【与休眠状态的区别是  休眠状态会自动唤醒，而永久等待状态需要调用notify()方法才能被唤醒】

  • 创建线程的方式

方式一：继承Thread父类  实现父类Run方法

public class Test2 {
    public static void main(String[] args){
        MakeHuotui makeHuotui = new MakeHuotui();
        GetHuotui getHuotui = new GetHuotui();

       makeHuotui.start();
       getHuotui.start();
    }
}
class MakeHuotui extends Thread{
    @Override
    public void run() {
        System.out.println("制作火腿....");
    }
}

class  GetHuotui extends Thread{
    @Override
    public void run() {
        System.err.println("获取火腿....");
    }
}
  • 方式二：实现Runable接口 
    package javaBase2;

public class Test2 {
    public static void main(String[] args){
        Thread t1 = new Thread(new MakeA());
        Thread t2 = new Thread(new GetA());
        t1.start();
        t2.start();
    }
}
class MakeA implements Runnable{
    @Override
    public void run() {
        for (int i=0; i<1000; i++){
            System.out.println(i);
        }
    }
}

class GetA implements Runnable{
    @Override
    public void run() {
        for (int i=0; i<1000; i++){
            System.err.println(i);
        }
    }
}

     

两者不同：

  • 一个是用继承实现  java是单继承模式，这样就是造成一个类的局限性
  • 一个是用接口接口实现，接口是多实现，这样就避免了类的局限性
  • 通过代码可以看到两者的启动方式也有所不同【一般推荐使用接口实现方式】

  • 多线程造成的一些问题：

    举个例子： 
    public class Test {
    public static void main(String[] args) {
        // 模拟买票案例  同时开启三个线程  共享票源资源
        RunableImpl run = new RunableImpl();

        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}


class RunableImpl implements  Runnable{
    // 定义多个线程共享的票源
    private  int ticket = 100;

    @Override
    public void run() {
            while(true){
                // 判断票是否存在
                if(ticket>0){
                    try {
//                        线程休眠10毫秒
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"-----> 正在卖第"+ticket+"号票");
                    ticket--;
                }else {
                    break;
                }
        }

    }
}

    这是一个模拟电影院买票场景，创建三个线程分别模拟三个售票窗口，共享电影票100张这个资源，这样会造成什么问题呢，请看结果：

现象1：出现卖出负数票

现象2：卖出相同的票

造成这个现象的原因：

怎么说呢，emmm只可意会不能言传，你可以这么理解线程在不断的抢占CPU资源，这个抢占的时间间隔是非常小的

理论上的你们可以看看这个B站的视频：线程安全问题产生的原理。

如何解决线程安全问题

  • 方法一：同步代码块

// 格式
synchronized(同步锁){
    // 需要同步操作的代码块
}
  • 锁对象：即自定义同步锁对象；
  • 将上面的例子改成一个同步代码块的形式： 
    package javaBase3;

public class Test {
    public static void main(String[] args) {
        // 模拟买票案例  同时开启三个线程  共享票源资源
        RunableImpl run = new RunableImpl();

        Thread t1 = new Thread(run);
        Thread t2 = new Thread(run);
        Thread t3 = new Thread(run);
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}


class RunableImpl implements  Runnable{
    // 定义多个线程共享的票源
    private  int ticket = 100;
//    创建一个锁对象  可以是任意对象
    private Object object = new Object();

    @Override
    public void run() {
        // 同步代码块
        synchronized (object){
            while(true){
                // 判断票是否存在
                if(ticket>0){
                    try {
//                        线程休眠10毫秒
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"-----> 正在卖第"+ticket+"号票");
                    ticket--;
                }else {
                    break;
                }
            }
        }


    }
}

    实现原理：通俗的理解就是 当一个线程抢占到CPU资源时，该线程就会拿到对象锁（对象监视器），直到同步代码块全部执行完毕

  • 方法二：同步方法

步骤：1 将访问了共享数据的的代码抽取出来，放到一个方法中  2 在方法上加上synchronized

锁对象：即实现Runable接口的实现类对象

将原例子改成一个同步方法

package javaBase4;

public class Test {
    public static void main(String[] args) {
        myThread mythread = new myThread();

        Thread t1 = new Thread(mythread);
        Thread t2 = new Thread(mythread);
        Thread t3 = new Thread(mythread);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }
}

class myThread implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {

        while (true) {
            payTicket();

        }
    }

    // 定义一个同步方法
    public synchronized void payTicket(){
        if (ticket > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在售出第------->" + ticket + "号票");
            ticket--;
        } else {
            System.err.println("票已经售光");
        }

    }
}

  • 方法三：静态同步方法

锁对象：静态方法的是优先于对象创建，所有它与同步方法的锁对象不同；静态方法的锁对象就是本类class属性--->class文件对象

package javaBase5;

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();


    }
}

class MyThread implements Runnable {
    private static int ticket = 100;

    @Override
    public void run() {
        MyThread.payTicket();

    }

    public static synchronized void payTicket(){
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在售出--------" + ticket + "号票");
                ticket--;
            } else {
                System.err.println("票已经卖完");
                break;
            }
        }
    }
}

  • 方法四：Lock锁：

在jdk1.5之后出现 lock实现了比synchronized方法和语句更广泛的的锁机制

Lock接口中的两个方法

       void lock()  获取锁

       void  unlock()   释放锁

Lock接口的一个实现类：ReentrantLock

使用步骤： 1  在成员位置创建一个ReetrantLock对象；  2  在可能出现线程安全问题的代码前调用lock接口中的方法 lock()获取锁

                   3  在可能出现线程安全问题的代码后调用lock接口中国的方法unlock()释放锁；

 

package javaBase5;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread implements Runnable {
    //    定义共享影票资源
    private static int ticket = 100;
    //    在成员位置创建一个ReentrantLock()对象
    Lock mylock = new ReentrantLock();

    @Override
    public void run() {
//        在可能出现线程安全问题的代码钱 使用lock接口中的方法lock（）获取锁
        mylock.lock();
        while (true) {
            if (ticket > 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在售出--------" + ticket + "号票");
                ticket--;
            } else {
                System.err.println("票已经卖完");
                break;
            }
        }
//        在可能出现线程安全问题的代码后，使用lock接口中的方法unloc（） 释放锁
        mylock.unlock();

    }
}

对上面的代码进行一个优化【即无论最后是否出现线程安全问题都将释放锁】

package javaBase5;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();

        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

class MyThread implements Runnable {
    //    定义共享影票资源
    private static int ticket = 10000;
    //    在成员位置创建一个ReentrantLock()对象
    Lock mylock = new ReentrantLock();

    @Override
    public void run() {
            while (true) {
                //在可能出现线程安全问题的代码钱 使用lock接口中的方法lock（）获取锁
                mylock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                        System.out.println(Thread.currentThread().getName() + "正在售出--------" + ticket + "号票");
                        ticket--;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        //在可能出现线程安全问题的代码后，使用lock接口中的方法unlock（） 释放锁
                        mylock.unlock();
                    }
                }else {
                    System.err.println("电影票已经售完");
                    break;
                }
            }
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

猫和老鼠和我
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程分析工具TDA
06-21
分析java线程日志的工具，使用jstack把java线程日志dump下来，然后上传到该工具，就可以查看线程阻塞情况等信息。
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
Java多线程详解及示例
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
详解Java线程堆栈
08-28
本篇文章主要给大家讲了Java线程堆栈的详细原理以及用法，需要的朋友跟着学习下吧。
深入理解java线程通信
08-25
开发中不免会遇到需要所有子线程执行完毕通知主线程处理某些逻辑的场景。或者是线程 A 在执行到某个条件通知线程 B 执行某个操作。下面我们来一起学习如何解决吧
HashSet的两种遍历方法
热门推荐
qq_41562587的博客
01-08 1万+
HashSet的两种遍历方法： public static void main(String[] args){ Set<String> set = new HashSet<String>(); set.add("a1"); set.add("b2"); set.add("c3"); set.add("d4"); // 初始化一个...
List集合的循环遍历方式
qq_41562587的博客
01-19 5289
List集合的特点： 有序 【存入 取出 元素顺序一致】 可重复 【判断重复的条件equals 如果是系统类型则无需重写equals方法 如果是自定义的类则需要重写equals方法】 子集合中有线程安全【vector】 也有线程不安全【ArrayList LinkedList】 List集合的三种遍历方式： // 创建一个ArrayList集合 我就用ArrayLis...
ArrayList和LinkedList的相爱相杀
qq_41562587的博客
01-07 134
ArrayList: 基于动态数据实现 向集合中添加 删除元素效率低 在集合中根据索引查找元素效率高 线程不安全【如何解决线程不安全的问题】 ArrayList如何实现动态扩容： 因为ArrayList基于数组实现的，所有ArrayList的扩容就是数组的扩容。 看下源码即可以知道默认开辟的数长度为10： ​ private static final int DEFAULT_C...
Java集合Collection接口下的List与Set
qq_41562587的博客
01-13 112
Collection常用的已知子接口 List【接口】 集合中的元素 有序 可重复 可以存放多个null值 部分子集合线程不安全【ArrayList LinkedList】 部分子集合线程安全【Vector】 list集合都可以根据索引查找对应的元素 Set【接口】 集合中的元素 无序 不可重复 可以存放一个null值 如何理解【有序 无序】【重复 不重复】...
ArrayList源码分析
qq_41562587的博客
05-13 109
ArrayList默认初始容量：10 /** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; ArrayList基于数组实现： /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList
Java排序算法知识巩固
qq_41562587的博客
05-13 95
选择排序： int[] arr = {516,466,1,46,684,13,58464,465}; int temp = 0; // 选择排序 for(int i=0; i<arr.length; i++){ for(int j=i+1; j<arr.length; j++){ if(arr[i]>arr[j]){ temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } ..
3796 i-FRAME 安装、操作和维护手册
04-27
3796 i-FRAME 安装、操作和维护手册
我的visio画图 资源备用
最新发布
04-27
我的visio画图
NPOI是指构建在POI 3.x版本之上的一个程序
04-27
NPOI可以在没有安装Office的情况下对Word或Excel进行读写，NPOI是一个开源的C#读写Excel、WORD等微软OLE2组件文档的项目
基于STM32F103C8单片机设计-旋转编码器数码管显示程序KEIL工程源码.zip
04-27
STM32学习软件编程资料，STM32F103C8单片机经典外设应用设计实例软件源代码，KEIL工程文件，可供学习参考。
VoLTE高丢包优化指导书.xlsx
04-27
VoLTE高丢包优化指导书
LTE容量优化高负荷小区优化指导书.docx
04-27
5G通信行业、网络优化、通信工程建设资料
中国移动无线、传输专业项目全生命周期、建设期、施工期控制标准.docx
04-27
5G通信行业、网络优化、通信工程建设资料
java 优化线程_JAVA线程优化
05-27
Java中线程的优化主要包括以下几个方面： 1. 线程池的使用：线程池可以避免频繁创建和销毁线程的开销，提高了线程的利用率。同时，线程池可以控制线程的数量，避免线程数量过多导致的系统负荷过大。 2. 合理设置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值