Java多线程核心技术(一)：基础知识总结

最新推荐文章于 2024-06-19 21:11:55 发布
最新推荐文章于 2024-06-19 21:11:55 发布
阅读量1.8k 收藏 5
点赞数
分类专栏： 多线程并发编程 文章标签： 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/supersnow0622/article/details/56494682
版权

概念

进程：进程是操作系统结构的基础，是一次程序的执行，是一个程序及其数据在处理机上顺序执行时所发生的活动，是程序在一个程序集合上运行的过程，它是系统进行资源分配和调度的一个基本单位。

线程：线程是进程中独立运行的子任务。使用多线程技术后，可以在同一时间运行更多不同种类的任务。

使用多线程

第一种方式：继承Thread类，并实现run方法

第二种方式：实现Runnable接口

注意：1、代码的运行结果与代码的顺序无关：线程是一个子任务，CPU以不确定的方式，或者说以随机的时间来调用线程中的run方法。

2、Thread.java类中的start()方法通知"线程规划器"此线程已经准备就绪，等待调用线程对象的run()方法。这个过程其实就是让系统安排一个时间来调用Thread中的run()方法，也就是使线程得到运行，启动线程，具有异步执行的效果，所以如果在程序中直接调用线程的run方法，那程序就是顺序执行的。


Thread类的结构：public class Thread implements Runnable

在Thread类的8个构造函数中，有两个构造函数Thread(Runnable target)和Thread(Runnable target,String name)可以传递Runnable接口，说明构造函数支持传入一个Runnable接口的对象。而Thread类实现了Runnable接口，所以完全可以将一个Thread对象作为Thread构造函数的参数传入，这样该Thread对象实现的run()方法就交由其他的线程进行调用。

共享数据

实现5个线程共同对一个count变量进行减法操作：

class MyThread extends Thread{
    public int count = 5;
    @Override
    public void run(){
    	super.run();
    	count--;
    	System.out.println("由 " + this.currentThread().getName() + "计算，count="+count);
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		Thread a = new Thread(mythread,"A");
		Thread b = new Thread(mythread,"B");
		Thread c = new Thread(mythread,"C");
		Thread d = new Thread(mythread,"D");
		Thread e = new Thread(mythread,"E");
		a.start();
		b.start();
		c.start();
		d.start();
		e.start();
	}
}
执行结果如下：


在JVM中，i--的操作分成如下3步：

（1）取得原有i值，

（2）计算i-1,

（3）对i进行赋值。

当五个线程同时进行操作i--时，其中的某个或某些线程在没执行完这三个步骤的情况下，其他的线程就插入进来了，就会造成结果的混乱。解决这个问题的方法是在润方法钱加synchronized关键字，保证run方法的原子性操作。synchronized可以在任意对象及方法上加锁，而加锁的这段代码称为”互斥区“或者”临界区“，当一个线程想执行同步方法里面的代码时，线程首先尝试去拿这把锁，如果能够拿到这把锁，那么这个线程就可以执行synchronized里面的代码。如果不能拿到这把锁，那么这个线程就会不断地尝试拿这把锁，直到能够拿到为止，而且是有多个线程同时去争抢这把锁。

currentThread()方法

currentThread()方法可返回代码段正在被哪个线程调用的信息。


当直接调用thread的run方法时，则run方法不是有其所在的线程去调用，而是由主线程去调用。

class MyThread extends Thread{
    public MyThread(){
    	System.out.println("构造函数开始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("构造函数结束");
    }
    @Override
    public void run(){
    	System.out.println("run方法开始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("run方法结束");
    }
}
    public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		Thread t = new Thread(mythread);
		t.setName("A");
		t.start();
	}
}


输出结果为： 

构造函数开始
Thread.currentThread().getName()=main
this.Name=Thread-0
构造函数结束
run方法开始
Thread.currentThread().getName()=A
this.Name=Thread-0
run方法结束
在调用MyThread构造函数的线程是Main线程，而调用mythread的run方法的是名称为A的线程。


isAlive()方法

isAlive()方法的功能是判断当前线程是否处于活动状态，活动状态就是线程已经启动且尚未终止。线程处于正在运行或准备开始运行的状态，就认为线程是“存活”的。

class MyThread extends Thread{
    public MyThread(){
    	System.out.println("构造函数开始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("Thread.currentThread().isAlive()=" + Thread.currentThread().isAlive());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("this.isAlive()" + this.isAlive());
    	System.out.println("构造函数结束");
    }
    @Override
    public void run(){
    	System.out.println("run方法开始");
    	System.out.println("Thread.currentThread().getName()=" + Thread.currentThread().getName());
    	System.out.println("Thread.currentThread().isAlive()=" + Thread.currentThread().isAlive());
    	System.out.println("this.Name=" + this.getName());
    	System.out.println("this.isAlive()" + this.isAlive());
    	System.out.println("run方法结束");
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		Thread t = new Thread(mythread);
		t.setName("A");
		t.start();
	}
}
程序运行结果如下： 

构造函数开始
Thread.currentThread().getName()=main
Thread.currentThread().isAlive()=true
this.Name=Thread-0
this.isAlive()false
构造函数结束
run方法开始
Thread.currentThread().getName()=A
Thread.currentThread().isAlive()=true
this.Name=Thread-0
this.isAlive()false
run方法结束
这说明MyThread在构造函数中并没有存活，由于把MyThread的run方法交给了其他线程运行，所以在run方法中MyThread也不是存活的。

sleep()方法

sleep()方法的作用是在指定的毫秒数内让当前“正在执行的线程”休眠（暂停执行）。这个“正在执行的线程”是指this.currentThread()返回的线程。

class MyThread extends Thread{
    @Override
    public void run(){
    	try {
    		System.out.println("run threadName=" + this.currentThread().getName()+" begin="+System.currentTimeMillis());        	
			Thread.sleep(2000);
			System.out.println("run threadName=" + this.currentThread().getName()+" end  ="+System.currentTimeMillis());
		    
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread mythread = new MyThread();
		System.out.println("begin="+System.currentTimeMillis());
		mythread.start();
		System.out.println("end  ="+System.currentTimeMillis());
	}
}
程序运行结果如下: 

begin=1487766083887
end  =1487766083887
run threadName=Thread-0 begin=1487766083887
run threadName=Thread-0 end  =1487766085888
由于main线程与Mythread2线程是异步执行的，所以首先打印的信息为begin和end。而MyThread2线程是随后运行的，在最后两行打印run begin和run end相关的信息。

getId()方法

getId()方法的作用是取的线程的唯一标识

停止线程

在Java中有以下3种方法可以终止正在运行的线程：

（1）使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

（2）使用stop方法强行终止线程，但是不推荐使用这种方法，因为stop方法和suspend及resume方法一样，都是作废过期的方法，使用它们可能会产生不可预料的结果。

如果使用stop方法强制让线程停止则有可能会使一下清理性的工作得不到完成。另一个情况就是对锁定的对象进行了“解锁”，导致数据得不到同步的处理，出现数据不一致的问题。

（3）使用interrupt方法中断线程，调用interrupt()方法仅仅是在当前线程中打了一个停止的标记，并不是真的停止线程。

判断线程是否是停止状态：

（1）this.interrupted()：测试当前的线程是否已经中断，静态方法。线程的中断状态由该方法清除。所以，连续两次调用该方法，则第二次调用返回false（在第一次调用已经 清除了其中断状态之后，第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

（2）this.isInterrupted()：测试当前线程是否已经中断，非静态方法，并不会清除状态标志。

public class TestClass{
	public static void main(String[] args){
		
		try {
			MyThread mythread = new MyThread();
			mythread.start();
			Thread.sleep(1000);
			mythread.interrupt();
			System.out.println("当前线程是否停止？ = "+Thread.interrupted());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
}
程序运行输出
当前线程是否停止？ = false

这是因为mythread线程终止了，但是main线程一直在运行，这个“当前线程”就是main，所以打印了false。

在沉睡中停止

如果在线程的sleep()状态下停止线程，会抛出java.lang.InterruptedException异常，并且清除停止状态值，使之变成false。先中断线程在调用sleep()方法，结果是一样的。

暂停线程

暂停线程意味着此线程还可以恢复运行。在Java多线程中，可以使用suspend()方法暂停线程，使用resume()方法恢复线程的执行。

在suspend与resume方法时，如果使用不当，极易造成公共的同步对象的独占，是的其他线程无法访问公共同步对象。

class MyThread extends Thread{
	private long i = 0;
    @Override
    public void run(){
    	while(true){
    		i++;
    	}
    }
}
public class TestClass{
	public static void main(String[] args){
		
		try {
			MyThread mythread = new MyThread();
			mythread.start();
			Thread.sleep(1000);
			mythread.suspend();
			System.out.println("main end!");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
	}
}
程序会打印出main end，但是将MyThread改为如下的写法，运行程序，控制台将不打印main end，这是因为当程序运行到println()方法内部停止时，同步锁未被释放。方法println()源代码如下所示： 

public void println(long x){
    synchronized(this){
        print(x);
        newLine();
    }
}

yield方法

yield方法的作用是放弃当前的CPU资源，将它让给其他的任务去占用CPU执行时间。但放弃的时间不确定，有可能刚刚放弃，马上又获得CPU时间片。

class MyThread extends Thread{
    @Override
    public void run(){
    	long beginTime = System.currentTimeMillis();
    	int count = 0;
    	for(int i = 0; i < 50000000; i++){
    		//Thread.yield();
    		count += i;
    	}
    	long  endTime = System.currentTimeMillis();
    	System.out.println("用时："+(endTime - beginTime) + "毫秒！");
    }
}
public class TestClass{
	public static void main(String[] args){
		MyThread thread = new MyThread();
		thread.start();		
	}
}
正常情况下执行时间用了3毫秒，把//Thread.yield()的注释去掉，用时3189毫秒！

线程的优先级

优先级较高的线程得到的CPU资源较多，也就是CPU优先执行优先级较高的线程对象中的任务。设置线程的优先级使用setPriority(int newPriority)方法。在Java中，线程的优先级分为1~10这10个等级，如果小于1或大于10，则JDK抛出异常throw new IllegalArgumentException()。

JDK中使用3个常量来预置定义优先级的值，代码如下：

public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;
在Java中，线程的优先级具有继承性，比如A线程启动B线程，则B线程的优先级与A是一样的。下面是代码实现的例子： 

class MyThread1 extends Thread{
    @Override
    public void run(){
    	System.out.println("MyThread1 run priority="+this.getPriority());
    	MyThread2 thread2 = new MyThread2();
    	thread2.start();
    }
}
class MyThread2 extends Thread{
    @Override
    public void run(){
    	System.out.println("MyThread2 run priority="+this.getPriority());
    }
}
public class TestClass{
	public static void main(String[] args){
		System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
		Thread.currentThread().setPriority(6);
		System.out.println("main thread begin priority="+Thread.currentThread().getPriority());
	    MyThread1 thread1 = new MyThread1();
	    thread1.start();
	}
}
程序运行结果为： 

main thread begin priority=5
main thread begin priority=6
MyThread1 run priority=6
MyThread2 run priority=6

守护线程

在Java线程中有两种线程，一种是用户线程，另一种是守护线程。

守护线程是一种特殊的线程，它的特性有“陪伴”的含义，当进程中不存在非守护线程了，则守护线程自动销毁。典型的守护线程就是垃圾回收线程，当进程中没有非守护线程了，则垃圾回收线程也就没有存在的必要了，自动销毁。

class MyThread extends Thread{
    private int i = 0;
	@Override
    public void run(){   	
		try {
			while(true){
	    		i++;
	    		System.out.println("i="+i);
	    		Thread.sleep(1000);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
    }
}
public class TestClass{
	public static void main(String[] args){		
		try {
			MyThread thread = new MyThread();
			thread.setDaemon(true);
			thread.start();
			Thread.sleep(5000);
			System.out.println("我离开thread对象也不再打印了，也就是停止了！");
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}
如下是执行结果，当main线程执行完，守护线程MyThread就销毁了。 

i=1
i=2
i=3
i=4
i=5
我离开thread对象也不再打印了，也就是停止了！




















SherryWang0622
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程核心技术学习（一）
liwenxia626的专栏
09-10 251
1.Thread可extends，子类只能继承一个父类，并且为Runnable的实现类；Runnable可implements，可实现多个。 public void ThreadTest extends Thread{     @Override     public void run(){         //TODO     } } public class Thread
Java核心技术 卷I：基础知识
生息之地
03-03 776
第一章 Java程序设计概述 太简单了，直接略过。 1.2 Java“白皮书”的关键术语 简单性：指相对于C++简单（指针、多重继承等），但设计者也并没有试图清楚C++中所有不适当的特性 面向对象：java与C++主要不同在于多重集成，以及接口概念 网络技能 健壮性 安全性 体系结构中立 可移植性 解释性：过去Java解释器可以在任何移植了解释器的机器上执行java字节码，现在使用即使编译器将字节码再翻译成机器码 高性能 多线程 动态性 第二章 Java程序设计环境 我选择使用了JetBrainde I
Java多线程核心技术一-多线程基础其他内容
geminigoth的博客
11-30 1055
出现这种情况就是因为String的两个值都是"AA"，两个线程是持有相同的锁，造成线程B不能执行。这就是String常量池所带来的问题，所以大多数情况下，同步synchronzied都不使用String作为锁对象，而改用其他的。例如 new Object()实例化一个新的object对象时，它并不放入缓存池中，或者执行new String()创建不同的字符串对象，形成不同的锁。在把synchronzied(string)同步块与String联合使用时，要注意常量池会带来一些意外。
多线程技术（全面介绍）
m0_60563771的博客
02-10 3779
最全的多线程介绍。从概念到掌握技术。
java多线程
最新发布
m0_46702681的博客
06-19 1371
javajava。
多线程技术
zenggeweiss的博客
05-19 4178
一、基本概念   多线程是Java语言的重要特性，大量应用于网络编程、服务器端程序的开发，最常见的UI界面底层原理、操作系统底层原理都大量使用了多线程。   我们可以流畅的点击软件或者游戏中的各种按钮，其实，底层就是多线程的应用。UI界面的主线程绘制界面，如果有一个耗时的操作发生则启动新的线程，完全不影响主线程的工作。当这个线程工作完毕后，再更新到主界面上。   我们可以上百人、上千人、上万人同时...
多线程详解（理论与实践的最佳融合方案）
IT小辉同学
05-26 1311
黄管迟暮，那南墙斑驳的残影，是我对你最后的一丝念想!!!
Java线程相关的基础知识【必备】
Carroll的博客
04-04 576
文章目录推荐阅读什么是线程Thread线程特点线程和进程的区别线程的创建和启动线程的创建线程的启动两种线程创建方式的比较第三种方式：实现Callable接口线程的生命周期线程控制方法线程同步线程同步的实现方案同步监视器锁机制优缺点线程通信线程池什么是线程池线程池的好处线程池的应用场合线程池参数 推荐阅读 JVM从入门到地狱，你想要的样子它都有（O(∩_∩)O）~~~ Java集合的这些知识,20...
Java核心技术 卷1 基础知识 原书第9版
01-31
《Java核心技术·卷1：基础知识（原书第9版）》共14章。第1章概述了Java语言与其他程序设计语言不同的性能；第2章讲解了如何下载和安装JDK及本书的程序示例；第3章介绍了变量、循环和简单的函数；第4章讲解了类和...
JAVA核心技术基础知识配套源代码
06-29
"JAVA核心技术基础知识配套源代码"提供了学习Java编程的基础实例，帮助初学者从零开始构建自己的Java知识体系。这个资源包的核心内容围绕Java的核心概念，包括但不限于类与对象、封装、继承、多态、异常处理、集合...
Java多线程相关知识总结
03-15
### Java多线程相关知识总结 #### 一、基本概念 多线程是现代编程语言中一项非常重要的特性，尤其在Java...以上就是关于Java多线程的基础知识总结，希望能帮助大家更好地理解和掌握Java多线程的相关概念和技术要点。
【JAVA多线程】多线程编程核心技术学习资料
03-02
这份"Java多线程编程核心技术"的学习资料应该涵盖了以上所述的各个知识点，并可能深入讨论了如何在实际项目中有效地应用多线程，解决并发问题，优化性能。通过阅读这本书，开发者可以深入理解Java多线程编程的核心...
Java核心技术 卷1 基础知识 原书第10版
01-03
《Java核心技术 卷1 基础知识》是Java编程领域的经典著作，原书第10版更是汇集了多年来Java语言发展的精华。本书主要涵盖了Java编程的基础知识，为读者提供了全面而深入的理解Java编程环境的必备知识。 首先，Java...
Java 了解多线程和创建多线程的方式
weixin_47498250的博客
05-27 200
在java中实现多线程有两种常见的创建方式：一种是继承Thread类，另一种是实现Runnable接口，下面就来介绍两种方法的使用。 继承Thread类： public class Demo { public static void main(String[] args) { MyThread m = new MyThread(); m.start(); for(int i=0;i<5;i++) { System.out.println("锄禾日当午
java多线程（超详细）
热门推荐
zdl66的博客
08-14 10万+
进程就是正在运行中的程序（进程是驻留在内存中的）是系统执行资源分配和调度的独立单位每一进程都有属于自己的存储空间和系统资源注意：进程A和进程B的内存独立不共享。
多线程技术概述
qq_45780458的博客
09-07 173
多线程技术概述 一、部分概念 1.线程与进程 1）进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间。 2）线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行。一个进程至少有一个线程，线程实际上是在进程基础之上的一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程。 2.线程调度 1）.分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。 2）.抢占式调度：优先让高级的线程使用CPU，如果线程的优先级相同，那么会随机选择一个
java多线程技术（全）
SnakeMonster
09-28 185
多线程知识多线程技术概述1.线程与进程2.线程调度3.同步与异步4.并发与并行*一、继承Thread二、Runnable三、 Thread类 常用的方法四、设置和获取线程名称五、线程休眠sleep六、线程阻塞七、线程的中断八、守护线程setDaemon(true)九、线程不安全问题十、线程安全1-同步代码块十一、线程安全2-同步方法十二、线程安全3-显示锁Lock十三、公平锁与非公平锁十四、线程死锁十五、多线程通信问题十六、线程的六种状态十七、Callable 是java中第三种线程实现的方法十八、L
多线程核心技术梳理(持续更新)
泡^泡
04-26 1518
CAS原理、影响服务器吞吐量的因素、线程/线程池/操作系统的生命周期、线程池参数和拒绝策略等
Java线程基础知识汇总（超详细版）
HSQdePYZ的博客
07-17 728
进程是指在计算机中运行的程序的实例。它是操作系统进行资源分配和调度的基本单位。一个进程可以包含多个线程，每个线程都共享该进程的资源，如内存、文件和打开的网络连接等。每个进程都有自己的地址空间，即独立的内存区域。线程是进程内的执行单元，也是CPU的最小执行单元。一个进程可以包含多个线程，每个线程执行不同的任务。线程共享进程的资源，包括内存、文件和打开的网络连接等。线程之间通过共享内存进行通信，因此比进程间通信更高效。由于线程共享同一进程的地址空间，所以多线程之间的切换更快。
Java多线程编程全面总结：从基础到高级特性
Java线程系列博文全面覆盖了Java多线程编程的基础和高级概念，包括但不限于以下知识点： 1. **概念与原理** - 深入理解操作系统中线程与进程的区别，强调多线程在多任务操作系统中的应用。 2. **创建与启动** - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值