java 线程的基本知识整理

最新推荐文章于 2022-07-16 20:00:08 发布
最新推荐文章于 2022-07-16 20:00:08 发布
阅读量118 收藏
点赞数
分类专栏： # Java基础 文章标签： java jvm 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45799833/article/details/114676757
版权

线程的基操

创建线程的五种方式

继承Thread

1.继承Thread并实现它的方法run()，方法里面是我们给线程的任务

static class Dee implements Thread {
		@Override
		public void run() {System.out.println("as");}
}
public static void main(String[] args) {
	    Dee dee = new Dee();
	    //线程启动
	    dee.start();
}

实现Runnable接口

2.Runnable接口，相当于创建一个任务，我们要执行这个任务的时候，就创建一个线程，然后传入这个任务—给线程一个任务

static class Dee implements Runnable {
        @Override
        public void run() {System.out.println("as");}
}
public static void main(String[] args) {
        Dee dee = new Dee();
        //通过构造方法将任务对象dee传入线程
        Thread t1 = new Thread(dee);
        t1.start();
}

匿名类实现

3.匿名类实现，只能创建一个执行指定任务的线程，若要创建多个重复任务的线程，则不该采取这种方式创建线程

public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("as");
            }
        };
        thread.start();
 /************************************************/
 //极端情况
         new Thread(){
            @Override
            public void run() {
                System.out.println("as");
            }
        }d.start();
}

实现Callable接口

Callable带返回值的线程

public static void main(String[] args) throws InterruptedException, ExecutionException {
        Callable<Boolean> dee = new Dee();
        FutureTask<Boolean> futureTask = new FutureTask<>(dee);
        Thread thread = new Thread(futureTask);
        //判断任务是否执行完毕
        futureTask.isDone();
        //可以主动取消任务，参数为true表示取消，返回值是boolean，返回true表示取消成功
        futureTask.cancel(true);
        thread.start();
        //要先将线程启动，才能调用get方法，否则会阻塞在那里
        boolean b = futureTask.get();
        System.out.println(b);
    }
    static class Dee implements Callable<Boolean> {
        @Override
        public Boolean call() throws Exception {
            for (int i = 0; i < 5; i++) {
                Thread.sleep(1000);
                System.out.println(i);
            }
            return true;
        }
    }

线程池

线程池–可以使线程重复使用，它也是一个线程，当任务执行完成之后，程序不会马上关闭，就是因为线程池还在等待接收，但若没有任务，一段时间之后会自动关闭。

缓存线程池，若线程池容量不足，扩容
ExecutorService service = Executors.newCachedThreadPool();
service.execute(任务对象（实现接口Runnable，重写run方法）);

定长线程池，任务排队执行
ExecutorService service = Executors.newFixedThreadPool(3);
service.execute(任务对象（实现接口Runnable，重写run方法）);

单线程线程池
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(任务对象（实现接口Runnable，重写run方法）);

周期定长线程池
ScheduleExecutorService service = Executors.newScheduledThreadPool();
service.schedule(三个参数【自己看一下说明】)
service.scheduleAtFixedRate(四个参数)

线程的常见方法

设置和获取线程名称

1.设置和获取线程名称的两个方法——setName、getName

public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
            						//得到当前线程的名称
                System.out.println(Thread.currentThread().getName());
            }
        };
        //设置线程的名称
        thread.setName("110");
        thread.start();
}

结果：

110

线程休眠

2.线程休眠方法——sleep

Thread thread = new Thread('传入某个任务');
thread.sleep(1000);//休眠1000毫秒即1秒

线程的中断

3.线程的中断：由线程自己决定是否中断。
因为若在外部直接掐死该线程，那么该线程就来不及释放某些资源，这将会导致内存垃圾，且垃圾可能无法被回收。
我们可以给线程（不是给任务对象）—打上中断标记。
然后当run方法里当调用sleep或wait方法时，线程会查看一下中断标记，
若标记为true，我们可以直接reuturn就结束线程，当然我们也可以不理会这个标记。
（注意当线程接收到标记为true，除了我们可以做些处理之外，该标记会自动改为false）

    public static void main(String[] args) throws InterruptedException {
        Dee dee = new Dee();
        Thread thread1= new Thread(dee);
        thread1.start();
        for (int i=0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
        //给线程打上中断标记
        thread1.interrupt();
    }
    //我们采用上面所说的创建线程的第二种方式，所以创建一个类实现Runnable接口
    static class Dee implements Runnable {
        @Override
        public void run() {
            for (int i=0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                //当我们被打上标记，就会运行这里的代码块
                    System.out.println("我们被打上中断标记了，不管，我们改回来!");
                    //我们其实什么都没做，它自己就会改回来了
                    System.out.println("现在标记为：" + Thread.currentThread().isInterrupted());
                }
                System.out.println(Thread.currentThread().getName()+"---"+i);
            }
        }
    }

结果：

Thread-0---0
main:0
Thread-0---1
main:1
Thread-0---2
main:2
Thread-0---3
main:3
main:4
Thread-0---4
我们被打上中断标记了，不管，我们改回来!
现在标记为：false
Thread-0---5
Thread-0---6
Thread-0---7
Thread-0---8
Thread-0---9

守护线程

4.守护线程：调用setDaemon(true);方法即可将线程设为守护线程，（注意参数为true时，才为守护线程）
用户线程：当进程里的所有用户线程结束，进程结束
守护线程：当所有用户线程结束，它就自动死亡

    public static void main(String[] args) throws InterruptedException {
        //通过匿名类实现来创建用户线程
        new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }.start();
        //创建守护线程
        Thread daemonThread = new Thread() {
            @Override
            public void run() {
            //设为无限循环，来试试守护线程是否会因为用户线程的结束而自动结束
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("我还活着。。。haha");
                }
            }
        };
        //设置该线程为守护线程
        daemonThread.setDaemon(true);
        daemonThread.start();
    }

结果：

我还活着。。。haha
Thread-0: 0
我还活着。。。haha
Thread-0: 1
我还活着。。。haha
Thread-0: 2
我还活着。。。haha
Thread-0: 3
我还活着。。。haha
Thread-0: 4

我们可以注意到，当用户线程结束后，守护线程也自动结束了，尽管它的run()方法是while(true)来进行无限循环，但可惜，一旦当所有的用户线程结束后，它也会自动结束。

同步代码块和同步方法

5.同步代码块和同步方法：要有锁对象的概念
当线程想要执行被锁对象锁住的代码块，就必须得到锁对象。若锁对象被其他线程抢到，则该线程等待，直到下次抢夺开始。抢到了就执行代码块，没抢到就继续等待，直到抢到为止。

下面就是由两个线程来输出0到4的数字，规则：必须有序且不重复。

    public static void main(String[] args) throws InterruptedException {
        Dee dee = new Dee();
        Thread t1 = new Thread(dee);
        Thread t2 = new Thread(dee);
        t1.start();
        t2.start();
    }
    static class Dee implements Runnable {
        private Object object = new Object();
        private int i;
        @Override
        public void run() {
            for (i = 0; i < 5; i++) {
                synchronized (object) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果：

Thread-0: 0
Thread-1: 0
Thread-1: 2
Thread-0: 2
Thread-1: 4
Thread-0: 4

以上的案例出现错乱，是因为for循环时，两个判断的时机不对。
案例分析：
当线程A判断循环，此时i=0，i<5,判断可以进，线程A就执行循环体里的代码。
但几乎时同一时刻，线程B也在判断，而线程A并没有走完循环，好让i=1。所以此时线程B判断的也是i=0，i<5,可以进。
此时线程A可能刚println打印完Thread-0: 0，正在休眠中。紧接着线程B也开始打印，此时线程A还没有第二次循环，说明i还是等于0，所以线程B也是输出Thread-1: 0。

以下是正确的案例：

static class Dee implements Runnable {
        private Object object = new Object();
        //若是不赋值，默认为0
        private int i;
        @Override
        public void run() {
            while (true) {
            //我们用object这个对象来做锁对象
                synchronized (object) {
                    if (i >= 5) break;
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                    i++;
                }
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果：

Thread-0: 0
Thread-1: 1
Thread-1: 2
Thread-0: 3
Thread-1: 4

由以上的两个案例，可以提示到我们，当我们使用同步方法或代码块的时候就要慎重考虑采用for，还有仔细思考不同线程执行的时机。
同步方法的案例：

    static class Dee implements Runnable {
        //若是不赋值，默认为0
        private int i;
        @Override
        public void run() {
            while (true) {
                if (print()) break;
                try {
                	Thread.sleep(10);
            	} catch (InterruptedException e) {
                	e.printStackTrace();
            	}
            }
        }
        public synchronized boolean print() {
            if (i >= 5) return true;
            System.out.println(Thread.currentThread().getName() + ": " + i);
            i++;
            return false;
        }
    }

注意：同步方法锁的是this，即该任务对象。

显示锁

Lock接口可以new一个它的子类ReentrantLock得到显示锁。

    public static void main(String[] args) throws InterruptedException {
        Dee dee = new Dee();
        Thread t1 = new Thread(dee);
        Thread t2 = new Thread(dee);
        t1.start();
        t2.start();
    }
    static class Dee implements Runnable {
        //若是不赋值，默认为0
        private int i;
        //声明一个显示锁
        Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                l.lock();
                if (i >= 5) return;
                System.out.println(Thread.currentThread().getName() + ": " + i);
                i++;
                l.unlock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果：

显示锁错误案例
原因是当我们的 if (i >= 5)为真时，return。此时虽然该线程结束了，但是他并没有释放锁对象，导致另一个线程一直在阻塞。

正确的案例：

static class Dee implements Runnable {
        //若是不赋值，默认为0
        private int i;
        //声明一个显示锁
        Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true) {
                l.lock();
                if (i >= 5){
                    l.unlock();
                    return;
                }
                System.out.println(Thread.currentThread().getName() + ": " + i);
                i++;
                l.unlock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

结果：

Thread-1: 0
Thread-0: 1
Thread-1: 2
Thread-0: 3
Thread-1: 4

公平锁：线程排队，不会出现一个线程连续抢到cpu时间片

static class Dee implements Runnable {
        //若是不赋值，默认为0
        private int i;
        //声明一个显示锁
        Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true) {
                l.lock();
                if (i >= 5){
                    l.unlock();
                    return;
                }
                System.out.println(Thread.currentThread().getName() + ": " + i);
                i++;
                l.unlock();
            }
        }
    }

结果：

Thread-1: 0
Thread-0: 1
Thread-1: 2
Thread-0: 3
Thread-1: 4

注意：以上程序的sleep语句，除了中断标记的方法要用到，其他的都是为了要差距明显，体现线程抢占式的cpu时间分配。
补充：线程的阻塞，当因某件事情比较消耗时间就可称之为阻塞：比如读取文件，或等待用户输入等。

izaogao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java多线程和并发知识整理
05-18
二、线程基础 2.1状态 2.2使用方式 2.3基础机制 2.4中断 2.5互斥同步 2.6线程合作 三、Synchronized 详解 3.1 使用 3.2 原理分析 3.3 JVM中锁的优化 3.4 Synchronized与Lock 3.5 扩展 四、volatile 详解 ...
Java线程基础知识汇总（超详细版）
HSQdePYZ的博客
07-17 441
进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
【Java篇】线程知识点总结
m0_64231944的博客
04-09 1125
(超全)线程知识点、及线程方面的一些理解性问题
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6215
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
【Java之多线程篇】——吐血整理Java多线程详解（知识点+代码）
qq_50497708的博客
03-25 5992
目录： 线程基本概念 并行\并发的区别 多线程优点和何时使用多线程 多线程创建的两种方式：继承Thread类、实现Runnable接口（代码） 线程的生命周期 线程的同步 用线程同步解决线程安全问题的方式（一）：同步代码快、同步方法、Lock锁（代码） 死锁 线程通信的例子——涉及wait()、notify()、notifyAll()） 面试题：sleep()和wait()的异同 生产者和消费者例题 用线程同步解决线程安全问题的方式（二）：实现Callable()接口、线程池 基本
java 线程知识点总结
qq_56350439的博客
04-22 3449
程序、进程、线程： 程序：是指含有指令和数据的文件，被存储在磁盘或其他的数据设备中，也就是说程序是静态的代码； 进程：是程序的一次执行过程，是代码在数据集合上的一次运行活动，是系统资源分配和调度的基本单位； 线程：是进程的一个执行路径， ...
java核心面试知识整理.pdf
04-12
对java工程师面试的常见题目进行汇总。java虚拟机、java集合、java多线程并发、java基础、SPRING原理、微服务、NETTY、RPC、网络、日志、zookeeper、kafka、rabbitmq、hbase等内容
JAVA核心面试知识整理.pdf
02-18
一篇Java进阶架构师之路的核心知识，同时也是面试时面试官必问的知识点，篇章也是包括了很多知识点，其中包括了有基础知识、Java集合、JVM、多线程并发、spring原理、微服务、Netty 与RPC 、Kafka、日记、设计模式、...
JAVA核心知识点整理.pdf
09-06
这个文档包含了我们日常用得到或者用不到的Java相关的大部分知识点。 包含：JVM，Java集合，Java多线程并发，Spring原理，Netty,Zookeeper,负载均衡，分布式缓存等等。
JAVA核心面试知识整理.rar
12-06
JVM、JAVA多线程并发、Spring原理、微服务、netty和rpc、网络、zk、kafka、MQ、HBase、MongoDB、设计模式、负载均衡、数据库、算法、大数据、云计算。。。
java线程知识总结
红豆和绿豆的博客
07-09 234
（1）线程的状态以及互相转换 NEW，RUNNABLE，WAITING，TIMED_WAITING，BLOCKED，TERMINATED new Thread（） ----NEW 准备就绪，等到cpu调度 RUNNABLE 线程执行遇到 synchroinized 则当前进入到BLCOKED WAITING状态，大多数人用线程 都不会出现这个状态 这个状态需要 Object.wait + 锁 一起使用才 可以，必须 synchroiized(对象)「 对象.wait(). 表示。当前线程先...
Java多线程知识总结
qq_26384433的博客
11-15 126
1.进程和线程 进程 独立的运行环境 一个程序或一个应用；线程 进程中执行的一个任务 可以共享进程中的资源 2.多线程编程的好处 多个线程并发执行提高程序的执行效率 3.用户线程和守护线程 java程序中创建一个线程，即为用户线程；守护线程在后台执行不会阻止jvm终止，守护线程创建的子线程依然是守护线程 4.如何创建一个线程 继承Thread，实现Runnable接口 5.有哪些不...
Java线程的基本知识总结
weixin_39330443的博客
07-17 109
（一）创建线程的方式 （1）实现Runnable接口 （2）继承Thread类 推荐使用接口，能够做到定义与实现分离，耦合更低 （二）关于线程的优先级 thread2.setPriority(Thread.MAX_PRIORITY) 等级越高，优先运行 （三）关于线程的yield的方法 关于yield方法，是指当前线程可能运行不太重要的任务，可以通过这个方法暗示操作系统线程调度我可...
四万字爆肝总结java多线程所有知识点（史上最全总结）
初心不忘、始终方得
07-14 7394
这是笔者历时三周左右总结的所有java多线程中的知识点，只要是多线程的问题这里都可以看到，笔者使用通俗易懂的语言介绍了各个场景，以及他们实现的原理，希望对路过的你有所帮助。
java线程知识点
weixin_71243923的博客
07-16 371
java线程知识点
java线程基础知识总结
仲斌
01-01 2967
java线程基础知识总结什么是线程线程的简单使用线程中断线程状态线程属性线程同步ReentrantLock类条件锁注意synchronized关键字同步阻塞volatile关键字线程局部变量stop 和suspend方法被弃用原因阻塞队列Callable、Future和FutureTask执行器 什么是线程 一个程序同时执行多个任务，通常每个任务称为一个线程。 进程和线程区别 进程拥有自己的一整套...
Java线程基础理论知识总结（熟练Java多线程开发必备）
何义竏
07-04 277
Java线程基础理论知识总结线程基础概念线程和进程的理解CPU核心数和线程数的关系CPU 事件轮转机制澄清并行和并发高并发编程的意义、好处和注意事项多线程程序需要注意事项Java里的线程Java 程序天生就是多线程的线程的启动与中止启动中止对Java 里的线程再多一点点认识深入理解run()和start()其他的线程相关方法join 方法线程的优先级守护线程线程间的共享和协作线程间的共享 线程基础概念 线程和进程的理解 进程是程序运行资源分配的最小单位 进程是操作系统进行资源分配的最小单位，分配 CPU、内
Java线程知识点总结
xiaoHui_1126的博客
03-25 504
文章目录线程和进程并发编程三要素【面试】Java中堆和栈有什么不同？(相对于线程来说)线程安全、线程同步、线程互斥、线程通信线程的生命周期线程的实现方式Runnable和Callable线程调度器(Thread Scheduler)和时间分片(Time Slicing)Future和FutureTask线程安全线程不安全竞态条件多线程同步synchronized关键字wait()方法与notify...
java多线程知识总结
qq_33699659的博客
12-02 203
进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守护线程都结束运行后才能结束。 多线程能满足程序员编写高效率的程序来达到充分利用 CPU 的目的。 线程的创建有三种： 1、继承Thread类代表线程 定义Thread类的子类，并重写run（）方法，run（）方法称为线程的执行体； 创建Thread类的子类的...
java基础知识点整理
最新发布
09-24
Java基础知识点整理如下： 1. Java的特点：面向对象，跨平台性，自动内存管理，强类型语言。 2. Java的数据类型：基本数据类型（int、double、boolean等），引用数据类型（类、接口、数组等）。 3. Java的控制语句：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值