JAVA高级应用之线程详解

最新推荐文章于 2022-07-18 11:31:55 发布
最新推荐文章于 2022-07-18 11:31:55 发布
阅读量338 收藏 1
点赞数
文章标签： 线程应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liurongsheng123/article/details/79274943
版权

JAVA高级应用之线程详解

线程的六种状态

创建一个线程 相当于cpu开辟了一个独立的执行路径
每个执行路径都是一个空间
创建线程 该线程就会拥有一个独立的栈空间
如果在同一个栈空间中 不符合先入栈和后出栈的规则

状态:
1.新建状态(new 线程对象)
2.运行状态(调用start方法)
3.受阻塞状态(等待cpu的执行资源)
4.休眠状态(调用了sleep(时间)的方法)
5.等待状态(调用了wait方法)
6.死亡状态(run方法执行完毕)

这里写图片描述

代码示例
package com.lanou3g.p02;

public class Demo08 {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 1; i < 50; i++) {
            System.out.println(Thread.currentThread().getName() + "-" + i);
        }
    }
}

匿名内部类创建线程

匿名内部类方式 
相当于创建了一个该类的子类的对象
new 父类名()或接口名{
    重写父类的方法
}
这里new出来的 就是这个类的 子类对象
对学生进行排序-方法一
public class Demo09 {
    public static void main(String[] args) {
        TreeSet<Student> set = new TreeSet<>(new MyComparator());
        set.add(new Student("张飞", 20));
        set.add(new Student("关羽",10));
        set.add(new Student("刘备", 15));
        for (Student student : set) {
            System.out.println(student);
        }
    }
}
class MyComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        return o1.getAge() - o2.getAge();
    }
}
对学生进行排序-方法二
public class Demo09 {
    public static void main(String[] args) {
        Comparator<Student> comparator = new Comparator<Student>() {

            @Override
            public int compare(Student o1, Student o2) {
                // TODO Auto-generated method stub
                return o1.getAge() - o2.getAge();
            }

        };
        TreeSet<Student> set = new TreeSet<>(comparator);
        set.add(new Student("张飞", 20));
        set.add(new Student("关羽",10));
        set.add(new Student("刘备", 15));
        for (Student student : set) {
            System.out.println(student);
        }
    }
}
对学生进行排序-方法三
public class Demo09 {
    public static void main(String[] args) {
        TreeSet<Student> set = new TreeSet<>(
                new Comparator<Student>() {

                    @Override
                    public int compare(Student o1, Student o2) {
                        // TODO Auto-generated method stub
                        return o1.getAge() - o2.getAge();
                    }
        });
        set.add(new Student("张飞", 20));
        set.add(new Student("关羽",10));
        set.add(new Student("刘备", 15));
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

创建线程的三种方式

方式一
public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println(Thread.currentThread().getName() + "我是方式一");
            }
        };
        thread.start();
    }
public static void main(String[] args) {
        new Thread() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                System.out.println(Thread.currentThread().getName() + "我是方式一");
            }
        }.start();;
    }
方式二
public static void main(String[] args) {
    Runnable runnable = new Runnable() {        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            System.out.println(Thread.currentThread().getName() + "我是方式二");
        }
    };
    Thread thread = new Thread(runnable);
    thread.start();
}
方式三
public class p10 {
    public static void main(String[] args) {
        Thread thread = new Thread(
                new Runnable() {

                    @Override
                    public void run() {
                        // TODO Auto-generated method stub
                        System.out.println(Thread.currentThread().getName() + "我是方式三");
                    }
                }
                );
        thread.start();
    }
}

public class p10 {
    public static void main(String[] args) {
        new Thread(
                new Runnable() {

                    @Override
                    public void run() {
                        // TODO Auto-generated method stub
                        System.out.println(Thread.currentThread().getName() + "我是方式三");
                    }
                }
                ).start();
    }
}

线程休眠

如果子线程中 出现异常 只能try...catch处理
Thread类是Runnable接口的 实现类
重写方法中的run方法
该方法没有抛出异常
所有Runnable接口的实现类(包括Thread类)
都不能在run方法中抛出异常 只能处理
package com.lanou3g.p02;

public class Demo11 {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread.sleep(10);
            System.out.println(Thread.currentThread().getName() + "我是主线程" + i);

        }
    }
}
class MyThread1 implements Runnable{

    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        // TODO Auto-generated method stub
        for(int i = 0; i < 50; i++) {
            System.out.println(i);
        }
    }

}
public class Demo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(
                new Runnable() {

                    @Override
                    public void run() {
                        // TODO Auto-generated method stub
                        for(int i = 0; i < 50; i++) {
                            try {
                                Thread.sleep(100);
                            } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                            System.out.println(Thread.currentThread().getName() + i);
                        }
                    }
                }
                );
        thread.start();
    }
}
package com.lanou3g;
/*
 * 卖火车票问题
 */
public class Demo05 {
    public static void main(String[] args) {
        TiketsRunnable tRunnable = new TiketsRunnable();
        // 创建1条线程 这条线程会执行 run方法(这条线程的任务)
        Thread t1 = new Thread(tRunnable);
        Thread t2 = new Thread(tRunnable);
        Thread t3 = new Thread(tRunnable);
        // 开启三个线程
        t1.start();
        t2.start();
        t3.start();
    }
}
/* 同步锁(同步代码块 )
 * 锁可以是任意对象 要保证 锁的唯一 三个线程都使用的是同一把锁
 * synchronized(对象锁) {

   }
 */
class TiketsRunnable implements Runnable{
    // 声明50个票 保证票是共享数据 只new一次该类的对象
    private int tickets = 50;
    // 创建了对象锁 保证唯一
    // 卖票方法
    @Override
    public void run() {
        while(true) {
            // 锁只要保证对象唯一就可以 填this
            synchronized (this) {
                // 操作的共享数据的代码
                if(tickets > 0) {
                    // 线程休眠一会
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    // 有票就卖一张
                    System.out.println(Thread.currentThread().getName() + "--" + tickets);
                    // 减少一张
                    tickets--;
                }else {
                        // 没票 结束循环
                        break;
                }
            }
            // 让线程让出cpu的资源
            Thread.yield();
        }

    }
}

同步锁

线程 遇到锁 就进 进代码块(携带锁)
当线程 执行完代码块中的代码 就把锁返还
线程 没有遇到锁 会在同步代码块外等着 遇到锁才能进

public class Demo06 {
    public static void main(String[] args) {
        TiketsRunnable1 tRunnable1 = new TiketsRunnable1();
        // 创建1条线程 这条线程会执行 run方法(这条线程的任务)
        Thread t1 = new Thread(tRunnable1);
        Thread t2 = new Thread(tRunnable1);
        Thread t3 = new Thread(tRunnable1);
        // 开启三个线程
        t1.start();
        t2.start();
        t3.start();
    }
}
class TiketsRunnable1 implements Runnable{
    // 静态方法的 同步代码块的锁 可以使用本类 类名.class
    // 声明50个票 保证票是共享数据 只new一次该类的对象
    private int tickets = 50;
    // 创建了对象锁 保证唯一
    private Object obj = new Object();
    // 卖票方法
    @Override
    public void run() {
        while(true) {
            if (sellTickets()) {
                break;
            }
            // 让出cpu资源
            Thread.yield();
        }
    }

    // 操作共享数据的方法
    // 在方法中添加synchronized关键词 把方法变成 同步方法
    // 同步方法肯定有锁
    public synchronized boolean sellTickets() {
        // 操作的共享数据的代码
        if(tickets > 0) {
            // 线程休眠一会
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 有票就卖一张
            System.out.println(Thread.currentThread().getName() + "--" + tickets);
            // 减少一张
            tickets--;
            return false;
        }else {
                // 没票 结束循环
            return true;
        }

    }   
}

死锁

死锁是由于争用资源而出现的问题,有两份资源,A线程,拿了一份,B线程也拿了一份,双方都需要对方手里的资源才能执行完自己的线程
而双方又不会主动让出自己的资源,而是拿着自己的资源等待另一份资源,由于两个线程没有完成自己的任务
所以不会释放自己的资源,双方一直等待 造成死锁问题

 模拟线程死锁
 1.需要两个锁对象(保证唯一)

public class Demo07 {
    public static void main(String[] args) {
        DieLockRunnable die = new DieLockRunnable();
        Thread t1 = new Thread(die);
        Thread t2 = new Thread(die);
        t1.start();
        t2.start();
    }
}
// A锁
class LockA{
// 构造方法私有化
    private LockA() {
    }
    // 定义一个常量 锁对象 不能修改(也不能创建)
    public static final LockA LOCK_A = new LockA();
}
// B锁
class LockB{
// 构造方法私有化
    private LockB() {   
    }
    public static final LockB LOCK_B = new LockB();
}
class DieLockRunnable implements Runnable{
    // 声明一个标记
    // 标记一个是先A后B
    //     一次是先B后A
    private boolean isTrue = true;
    @Override
    public void run() {
        // 死循环(增加死锁几率)
        while (true) {
            // 按标记 
            if(isTrue) {
                // A锁-->B锁  同步锁 一次只进入一个线程
                synchronized (LockA.LOCK_A) {
                    System.out.println("if...LOCK_A");
                    synchronized(LockB.LOCK_B) {
                        System.out.println("if...LOCK_B");
                    }
                }
            }else {
                // B锁-->A锁
                synchronized (LockB.LOCK_B) {
                    System.out.println("else...LOCK_B");
                    synchronized (LockA.LOCK_A) {
                        System.out.println("else...LOCK_A");
                    }
                }
            }
            isTrue = !isTrue;
        }
    }

}

jdk1.5锁

Lock 接口
使用lock锁
lock.lock();
try{
    写操作共享数据的代码
}finally{
    lock.unlock();
}
接口实现创建线程的好处:
1.避免了直接继承Thread类的局限性(避免单继承)
2.接口即插即用 减少类与类之间的联系(可以解耦)
package com.lanou3g.p02;

import java.util.concurrent.locks.ReentrantLock;

public class Demo15 {
    public static void main(String[] args) {
        Tickets tickets = new Tickets();
        Thread thread = new Thread(tickets);
        Thread thread2 = new Thread(tickets);
        Thread thread3 = new Thread(tickets);
        thread.start();
        thread2.start();
        thread3.start();
    }
}
class Tickets implements Runnable{
    private int tickets = 50;
    private ReentrantLock  ree = new ReentrantLock();
    @Override
    public void run() {
        while(true) {
            ree.lock();
            try {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                if(tickets > 0) {
                    System.out.println(Thread.currentThread().getName() + " " + tickets);
                    tickets--;
                }else {
                    break;
                }
                }finally {
                    ree.unlock();
                }
                Thread.yield();
        }
    }

}
liurongsheng123
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java多线程高级应用
韩小文的博客
03-02 1806
1.线程概念 java所谓多线程，顾名思义，就是多道线程执行线索，那么为什么要多线程呢？如果你的部分代码在执行某个i/o操作而受阻，那么程序的其他部分也不能执行，这样就严重的浪费了cpu，多线程机制就是为解决这个问题。 多进程并行执行时，在cpu上执行的某个进程因为等待某种资源而受阻时，多任务操作系统可以使进程挂起，而根据FIFO原则，时间片轮转等启动另一个不同的进程执行，直到前一进程获得
Java线程 高级使用
07-02
Java线程 高级使用线程 Java线程
Java高级之线程(一)
ling的博客
12-03 1291
进程的定义 进程（Process）是系统进行资源分配和调度的一个独立单位。程序只是一组指令的有序集合，它本身没有任何运行的含义，只是一个静态实体。而进程则不同，它是程序在某个数据集上的执行，是一个动态实体。换句话说，程序并不能单独执行，只有将程序加载到内存中，系统为他分配资源后才能够执行，这种执行的程序称之为进程，当你运行一个程序，你就启动了一个进程。 例如:当你打开一
Java线程高级篇JUC
一只黑猩猩
06-15 512
JUC（Java.util.concurrent） volatile 当不同线程操作相同共享数据时，这个共享数据是彼此不可见的，所以出现了内存可见性问题。同步锁（synchronized）可以解决该问题，但是效率较差。因此，Java 提供了一种稍弱的同步机制：volatile。 volatile 关键字修饰变量，用来确保将变量的更新操作通知到其他线程，保证内存可见性。（注意，volatile修饰的变量无法进行重排序） 可以将 volatile 看做一个轻量级的锁，但是又与锁有些不同： 对于多线程，不是一
Java高级技术第五章——高并发之线程池
技术笔记
04-23 5413
前言 前言点击此处查看: http://blog.csdn.net/wang7807564/article/details/79113195 线程池 线程的开启和回收是要消耗系统性能的，对于大量使用线程的场景，使用线程池来进行管理，实现单个线程的复用，提高并发效率。 Callable 对Runnable进行了扩展，相对于Runnable接口,Callable的调用是可以有返回值的。...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是理解多任务并发执行的关键。在计算机系统中，进程和线程是两种不同的执行单元。 1. **进程**：每个进程都有独立的内存空间，这意味着不同进程之间的数据不能直接共享。例如，当你打开多...
Java多线程编程深入详解.docx
最新发布
10-24
多线程详解 多线程编程中，有许多重要的概念和技术，例如线程同步、线程通信、线程池、锁机制等。线程同步机制用于控制多线程之间的执行顺序，例如synchronized关键字、Lock接口等。线程通信机制用于实现多线程之间...
Java多线程详解
08-10
以上是对"Java多线程详解"主题的详细阐述，涵盖了Java多线程的基本概念、实现方式、线程控制、线程池、并发集合、线程间通信以及并发编程中常见的问题和解决方案。学习和熟练掌握这些内容对于开发高效的多线程Java...
Java使用Condition控制线程通信的方法实例详解
08-25
Java 使用 Condition 控制线程通信的方法实例详解 Java 中，Condition 类是 Lock 接口的一个补充，它提供了一种机制来让线程等待某个条件的满足，然后继续执行。Condition 将同步监视锁方法（wait、notify 和 ...
java应用详解
02-16
Java是一种广泛使用的面向对象的编程语言，由...总的来说，Java应用详解涵盖了从基础语法到高级特性的广泛内容，涉及Java开发的各个环节，无论是初学者还是经验丰富的开发者，都可以从中找到提升技能和解决问题的方法。
java线程高级(中)
rentian1的博客
03-21 136
字符编码（ASCII、ANSI、GB2312、UTF-8等）系统梳理
冰河
01-31 7208
鉴于CSDN对**版权保护的不作为**以及落后的运营手段，本博客将于近期关闭，并清空全部文章。 原有文章将会经过再次的校对、整理，转移至本人在**简书**的[博客空间](https://www.jianshu.com/u/3ec23ef9a408)。 ...
java高级编程——多线程（一）之实现多线程
晃在云淡风轻
05-29 1552
文章目录线程与进程并行与并发JVM虚拟机是多线程的吗多线程实现继承Thread类实现Runnable接口两种方法的区别与联系利用Callable接口实现多线程 线程与进程 线程和进程一样，都是实现并发的一个基本单位。 线程是依赖进程存在的。先来说进程，进程就是程序的一次动态执行过程。通俗来讲，进程就是正在运行的程序，它是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。 ...
java高级应用：线程池全面解析
weixin_34018169的博客
08-13 4004
什么是线程池？ 很简单，简单看名字就知道是装有线程的池子，我们可以把要执行的多线程交给线程池来处理，和连接池的概念一样，通过维护一定数量的线程池来达到多个线程的复用。 线程池的好处 我们知道不用线程池的话，每个线程都要通过new Thread(xxRunnable).start()的方式来创建并运行一个线程，...
Java高级---多线程
ljheee的博客
03-03 993
进程 和 线程：  现在基本都支持多进程，一个程序的不同功能（不同任务）依靠不同的线程来完成，线程的调度依靠操作系统cup决定，cup使用权是轮换式的、抢占式的，跟线程的优先级有关。  进程：一个应用程序的一次执行；一个内存中运行的应用程序，都有自己独立的一块内存空间。一个进程可启动多个线程。    线程：应用程序多个任务的细化。线程是依赖于进程去活动的，不会额外占用资源。线程是进程中的一
Java高级应用多线程部分的基础知识整理
小K工作室
03-17 141
程序，进程，线程的关系 程序program): 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process): 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期  如：运行中的QQ，运行中的MP3播放器程序是静态的，进程是动态的,进程作为资源分配的单位，系统在运行时会为每个进程分配不同的...
Java多线程之进阶篇（一）
热门推荐
Tomdogs的专栏
07-30 4万+
在学习完Java多线程之基础篇（一）和Java多线程之基础篇（二）后接下来开始学习Java多线程之进阶篇的内容。 Java 5 添加了一个新的包到Java平台，这个包是java.util.concurrent包（简称JUC）。这个包包含了有一系列能够让Java的并发编程更加轻松的类。本文使用的Java 7 版本的JUC，下面让我们继续来学习吧！ 一、JUC中实现多线程的两种方式 1.1 使用...
JAVA高级篇----线程
莫绝岚的小屋
07-18 835
线程和进程的详解，线程的基本使用，线程的多种实现方式及线程的工作原理，死锁问题及线程池的详细使用
java高级の多线程编程(高级篇)
神域_の_思念
09-07 540
本文内容： Java内存模型 线程特征 多线程控制 容器 线程池 一、Java内存模型 1. Java程序执行流程 如上图所示： - 1. '.java'文件会通过`Java编译器（Java Compiler）`（'javac'命令）,并编译成'.class'文件。 - 2. '.class'文件通过`类加载器(Class Loader)`,进入`Java虚拟机（JVM）`中。 - 3. 然后由`JVM`执行引擎执行。 Java内存模型指的就是 Runtime Data Area(运行时数据区)，

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值