java架构学习——1. 多线程快速入门

最新推荐文章于 2023-02-17 19:10:43 发布
最新推荐文章于 2023-02-17 19:10:43 发布
阅读量181 收藏
点赞数
分类专栏： java架构学习 文章标签： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmq_fly/article/details/83003887
版权

本篇博文主要包含：

  • 进程、线程及多线程的基本概念
  • 线程创建的五种方式
  • 线程常用api
  • 守护线程与非守护线程（用户线程）
  • 线程的五种状态
  • join()、yield()和priority()方法

一. 线程基本概念

  1. 进程：每个正在系统上运行的程序都是一个进程，如QQ等。每个进程包含一到多个线程。

  2. 线程：线程是一组指令的集合，或者是程序的特殊段，它可以在程序里独立执行。即正在独立运行的一条执行路径。

  3. 多线程：能够在同一时间执行多于一个线程，每个线程都能独立运行，互不影响，进而提高了程序的效率，而不提高带宽速度。在多线程中如果其中一个线程抛异常执行中断，而其他线程却不会受其影响。
    一个操作系统中可以有多个进程，每个进程中一定会有一个决定代码执行顺序的主线程，如main函数。

  4. 线程创建有哪些方式：
    （1）继承Thread类
    （2）实现Runnable接口
    （3）使用匿名内部类
    （4）Callable类
    （5）使用线程池创建线程（企业中常用）
    使用实现Runnable接口比继承Thread类好，因为可以实现多个接口和继承一个类，另外还符合面向接口开发。

  5. 单线程与多线程的区别：单线程中代码从上往下执行，相当于同步，如果其中某个方法中的代码挂了，其下面的代码就不能继续执行了；多线程就相当于异步，同时可以执行多个方法，其中一个方法中的代码挂了，不会影响其他方法的执行。

二. 线程创建方式代码实现

  1. 继承Thread类
public class ThreadDemo{

	public static void main(String[] args) {
		//调用线程
		Thread01 thread01 = new Thread01();
		//启动线程，不是调用run方法，而是调用start方法。
		//启动线程后，代码不会从上往下执行。
		thread01.start();
		for(int i=0; i<5; i++) {
			System.out.println("main:"+i);
		}
	}
}

class Thread01 extends Thread{

	//run方法中编写多线程需要执行的代码
	@Override
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println("childern:"+i);
		}
	}
}

运行结果：
在这里插入图片描述

  1. 实现Runnable接口
public class RunnableDemo {
	public static void main(String[] args) {
		//调用线程
		Thread02 t = new Thread02();
		Thread thread = new Thread(t);
		//启动线程
		thread.start();
		for(int i=0; i<5; i++) {
			System.out.println("main:"+i);
		}
	}

}

class Thread02 implements Runnable{
	//run方法中编写多线程需要执行的代码
	@Override
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println("childern:"+i);
		}
	}
}

运行结果：
在这里插入图片描述

  1. 使用匿名内部类
public class AnonymousDemo {
	public static void main(String[] args) {
		Thread thread = new Thread(new Runnable() {
			//run方法中编写多线程需要执行的代码
			@Override
			public void run() {
				for(int i=0; i<5; i++) {
					System.out.println("childern:"+i);
				}
			}
		});
		//启动线程
		thread.start();
		
		for(int i=0; i<5; i++) {
			System.out.println("main:"+i);
		}
	}
}

运行结果：
在这里插入图片描述

  1. Callable类，相较于实现 Runnable 接口的方式，区别在于Callable有返回值并且可以抛出异常。
public class CallableDemo {
	 //相较于实现 Runnable 接口的方式，区别在于Callable有返回值并且可以抛出异常。
	 static class SumTask implements Callable<Long> {
	        @Override
	        public Long call() throws Exception {
	            long sum = 0;
	            for (int i = 0; i < 5; i++) {
	            	 sum += i;
	                System.out.println("childern: "+i);
	            }
	            System.out.println("sum: "+ sum);
	            return sum;
	        }
	    }

	    public static void main(String[] args) throws ExecutionException, InterruptedException {
	      //执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
	        FutureTask<Long> futureTask = new FutureTask<Long>(new SumTask());
	        //执行线程方式一:
	        /*Executor executor=Executors.newSingleThreadExecutor();
	        executor.execute(futureTask);*/
	        //执行线程执行线程方式二:
	        new Thread(futureTask).start();
	       
	        for (int i = 0; i < 5; i++) {
                System.out.println("main: "+i);
            }
	        System.out.println("返回值： "+futureTask.get());
	    }
}

运行结果：
在这里插入图片描述
Callable常用api

boolean cancel(boolean mayInterruptIfRunning)如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。参数：mayInterruptIfRunning - 如果应该中断执行此任务的线程，则为 true；否则允许正在运行的任务运行完成。返回值：如果无法取消任务，则返回 false，这通常是由于它已经正常完成；否则返回 true
boolean isCancelled()返回值：如果在任务正常完成前将其取消，则返回 true。
boolean isDone()返回值：如果任务已完成，则返回 true。 可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true。
V get()返回值：如有必要，等待计算完成，然后获取其结果。
V get(long timeout,TimeUnit unit)返回值：如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

代码演示：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;

public class CallableDemo {
	 //Callable和Runnbale一样代表着任务，区别在于Callable有返回值并且可以抛出异常。
	 static class SumTask implements Callable<Long> {
	        @Override
	        public Long call() throws Exception {
	            long sum = 0;
	            for (int i = 0; i < 5; i++) {
	                sum += i;
	                System.out.println("childern: "+i);
	            }
	            System.out.println("sum: "+ sum);
	            return sum;
	        }
	    }

	    public static void main(String[] args) throws ExecutionException, InterruptedException {
	        System.out.println("Start:" + System.nanoTime());
	        
	        //执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
	        FutureTask<Long> futureTask = new FutureTask<Long>(new SumTask());
	        //执行线程方式一:
	        Executor executor=Executors.newSingleThreadExecutor();
	        executor.execute(futureTask);
	        //执行线程执行线程方式二:
	        //new Thread(futureTask).start();
	      
	        //Thread.sleep(10);
	        //取消线程,如果无法取消任务，则返回 false，这通常是由于它已经正常完成；否则返回 true
	        //futureTask.cancel(true);
	        try {
	    	 //取得返回值
		     System.out.println("返回值: "+futureTask.get());
		    // 如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。
		     System.out.println("返回值: "+futureTask.get(1, TimeUnit.SECONDS));
			} catch (Exception e) {
				e.printStackTrace();
			}
	        
	        //如果在任务正常完成前将其取消，则返回 true。
	        System.out.println("是否被取消： "+futureTask.isCancelled());
	        //如果任务已完成，则返回 true。 可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回 true。
	        System.out.println("任务是否完成： "+futureTask.isDone());
	        
	        System.out.println("End:" + System.nanoTime());
	    }
}

运行结果：
在这里插入图片描述

  1. 使用线程池创建线程（企业中常用）（见后续）
  2. 常用线程api
start()start() 启动线程
currentThread()获取当前线程对象
getId()获取当前线程ID Thread-编号 该编号从0开始
getName()获取当前线程名称
sleep(long mill)休眠线程
Stop（）停止线程，不安全，不推荐使用
start()start() 启动线程
Thread（）分配一个新的 Thread 对象
Thread（String name）分配一个新的 Thread对象，具有指定的 name正如其名。
Thread（Runable r）分配一个新的 Thread 对象
Thread（Runable r, String name）分配一个新的 Thread对象，具有指定的 name正如其名。

代码演示：

public class RunnableDemo {
	public static void main(String[] args) {
		//调用线程
		Thread02 t = new Thread02();
		Thread thread = new Thread(t);
		//启动线程
		thread.start();
		for(int i=0; i<5; i++) {
			System.out.println("main:"+i+"; 线程id: "+Thread.currentThread().getId()+" ;线程name: "+Thread.currentThread().getName());
		}
	}
}

class Thread02 implements Runnable{
	
	@Override
	public void run() {
		for(int i=0; i<5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("childern:"+i+"; 线程id: "+Thread.currentThread().getId()+" ;线程name: "+Thread.currentThread().getName());
		}
	}
}

运行结果：
在这里插入图片描述

三. 守护线程与非守护线程
Java分为两种线程：非守护线程和守护线程
（1）非守护线程（又称用户线程）：用户自己创建的线程，如果主线程停止掉，不会影响到到用户线程，和主线程互不影响。
（2）守护线程：指在程序运行的时候在后台提供一种通用服务的线程，比如垃圾回收线程。守护线程会和主线程一起销毁。
代码演示：

public class ThreadDemo{

	public static void main(String[] args) {
		//调用线程
		Thread01 thread01 = new Thread01();
		//设置该线程为守护线程,与主线程一起销毁
		thread01.setDaemon(true);
		//启动线程
		thread01.start();
		for(int i=0; i<5; i++) {
			System.out.println("main:"+i);
		}
		System.out.println("主线程执行完毕~~~~~");
	}
}

class Thread01 extends Thread{
	@Override
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println("childern:"+i);
		}
	}
}

thread01为用户线程时，运行结果：
在这里插入图片描述
thread01为守护线程时，运行结果：
在这里插入图片描述
四. 线程的五种状态
线程的五种状态：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
在这里插入图片描述

（1）新建状态(New)：
当用new操作符创建一个线程时， 例如new Thread®，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码。
（2）就绪状态(Runnable)
一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
（3）运行状态(Running)
当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.
（4）阻塞状态(Blocked)
线程运行过程中，可能由于各种原因进入阻塞状态:
1>线程通过调用sleep方法进入睡眠状态；
2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3>线程试图得到一个锁，而该锁正被其他线程持有；
4>线程在等待某个触发条件；
…
所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
（5）死亡状态(Dead)
有两个原因会导致线程死亡：
1) run方法正常退出而自然死亡，
2) 一个未捕获的异常终止了run方法而使线程猝死。
为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false.

五. join、yield和priority方法

  1. join()的作用：是让其他线程变为等待，直到当前线程执行完毕，才释放。
  2. yield()的作用：暂停当前正在执行的线程，并执行其他线程。（可能没有效果）
  3. priority()：来控制优先级，范围为1-10，其中10最高，默认值为5。
    代码演示：
public class ThreadJoinDemo {
	//thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
	//比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
	public static void main(String[] args) {

		final Thread t1 = new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=0; i<50; i++) {
					System.out.println("t1: "+ i);
				}	
			}
		});
		// 注意设置了优先级， 不代表每次都一定会被执行。 只是CPU调度会有限分配
		t1.setPriority(10);
		t1.start();
		
		final Thread t2 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					t1.join();// 让其他线程(t2)变为等待，直到当前t1线程执行完毕，才释放。
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				for(int i=0; i<50; i++) {
					System.out.println("t2: "+ i);
				}
			}
		});
		t2.start();
		
		Thread t3 = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					t2.join();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				for(int i=0; i<50; i++) {
					System.out.println("t3: "+ i);
				}	
			}
		});
		t3.start();
	}
}
wmq_fly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java 高并发编程详解：多线程与架构设计
GitChat
12-10 6858
内容简介 本书主要包含四个部分： 部分主要阐述 Thread 的基础知识，详细介绍线程的 API 使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了 ClassLoader，这是因为 ClassLoader 与线程不无关系，我们可以通过 synchronized 关键字，或者 Lock 等显式锁的方式在代码的编写阶段对共享资源进行数据一致...
java操作WebSphereMQ
最新发布
weixin_44103465的博客
02-17 2065
Java 安装调用WebShereMQ
Java使用WMQ实现远程通讯.docx
05-25
Java客户端将消息发送到客户端队列，消息经过通道到达远程队列。使用java服务端程序读取消息
wmqjava
midikang的博客
11-06 117
运行WMQ的java样例MQSample.java所需的jar包： connector.jar com.ibm.mq.jmqi.jar com.ibm.mq.jar com.ibm.mq.headers.jar com.ibm.mq.commonservices.jar [img]http://dl.iteye.com/upload/attachment/0076/2319/9...
Java远程连接IBM MQ
勿忘初心方得始终
10-12 6374
一、准备工作 1.需要在mq服务器上新建一个队列管理器、一个发送队列、一个接收队列、一个服务器通道 2.启动队列管理器(SEND)   strmqm  SEND --启动监听(SL)   runmqlsr -m SL -p 1414 -t tcp &amp; --用户交互管理界面程序  runmqsc  SEND --创建本地队列  DEFINE QLOCAL (Q1) --创建的服务器连...
java多线程（1）——thread入门讲解
木子 旭的博客
11-18 468
Process与Thread的关系 Process是进程，Thread是线程； 在一个操作系统中，也就是一台电脑中，有多个进程，每个运行的程序对应一个进程； 一个进程可以并发多个线程； 为什么要多线程 如果在单线程中中涉及到IO输入和输出的话，cpu就只有等待该io操作后完成后才能继续该线程，这样的话，一个用户的IO操作将会导致程序其他的代码块不能被执行。我们需要使用多线程来同时对多个用户提供服务，给每个用户分配一个线程，如果遇到IO操作导致线程被挂起，其他用户的线程不会受影响。 多线程的好处 多线程开发
java 多线程数组越界_越界java数组
weixin_36370851的博客
02-25 1134
Java控制内存的功力卷首语：本文选自《Java程序员，上班那点事儿》第4章控制内存的功力那本谭浩强主编的Java入门教材说：……Java的语言特点：……4、健壮性……Java用真正的数组代替了C++的指针运算，可以进行数组元素的越界检查。Java程序在没有授权的情况下是不能访问内存的。所有这些措施，...文章技术小胖子2017-11-09743浏览量java 数组1. 使用数组的声明有两种方式...
Java——聊聊JUC中的CAS原理
★★光亭★★
09-28 3701
Java——聊聊JUC中的CAS原理
成神之路思维导图——Hollis.zip
03-05
"Java工程师成神之路2020版——高级篇.png"则深入到更复杂的主题，比如反射机制、动态代理、JVM内存模型、垃圾回收机制、性能优化、多线程高级应用、NIO（非阻塞I/O）以及设计模式（如工厂模式、单例模式、装饰器...
Android编程快速入门——字节跳动.pptx
08-24
Java 的特征包括平台独立、对象orientation、多线程支持、动态加载等。 Java 数据类型包括基本数据类型和引用数据类型。基本数据类型包括 boolean、byte、char、short、int、long、float、double 等。引用数据类型...
2021年最新Java后端学习路线，适用于所有想要踏入Java行业的初学者（csdn）————程序.pdf
12-01
以下是一份2021年更新的Java后端学习路线，旨在帮助入门者逐步深入Java世界。 首先，基础阶段是学习任何编程语言的关键。在Java的世界里，你需要掌握基础语法、数据类型、方法、面向对象编程概念以及异常处理。理解...
java架构师零基础学习01-05天.rar
06-30
本压缩包文件“java架构师零基础学习01-05天.rar”提供了一个初步的学习路径，涵盖了Java编程的基础知识，旨在帮助新手快速入门。 首先，Day01的内容是Java开发环境的搭建以及编写第一个程序——HelloWorld。在Java...
Java学习从入门到精通.docx
10-30
此外，还要学习异常处理、集合框架、I/O流、网络编程、多线程、数据库连接（JDBC）等核心概念和技术。随着技能的提升，还可以进一步探索Spring框架、Hibernate ORM、Maven构建工具、JUnit测试框架等进阶主题。 总之...
Java8之——Lambda表达式入门
冰河的专栏
09-22 3120
转载自：http://blog.csdn.net/renfufei/article/details/24600507/ 原文链接: Start Using Java Lambda Expressions 下载示例程序 Examples.zip 。 原文日期: 2014年4月16日 翻译日期: 2014年4月27日 翻译人员: 铁锚 简介 (译者注:虽然看着很先进，其实Lamb
java队列控制推荐_java – WSMQ队列限制
weixin_33520805的博客
03-02 1888
我可以在单个连接和单个会话中打开多少个队列？我现在可以打开128个队列并向他们发送消息.如果我尝试打开129,我会收到以下错误…谢谢com.ibm.msg.client.jms.DetailedResourceAllocationException: JMSWMQ2008: Failed to open MQ queue 'TestQueue_129'. JMS attempted to perf...
java架构学习——17. 表单重复提交&防止模拟请求&跨域解决方案&XSS攻击
wmq_fly的博客
02-15 727
一、http长连接与短连接 在HTTP/1.0中，默认使用的是短连接。也就是说，浏览器和服务器每进行一次HTTP操作，就建立一次连接，但任务结束就中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源，如JavaScript文件、图像文件、CSS文件等；当浏览器每遇到这样一个Web资源，就会建立一个HTTP会话。 但从 HTTP/1.1起，默认使用长连接，用以保...
java架构学习——15. Cookie与Session实现原理&外网映射工具的使用
wmq_fly的博客
02-15 461
一、Web开发入门 1、软件的结构 C/S (Client - Server 客户端-服务器端) 典型应用：QQ软件 ，飞秋，红蜘蛛。 特点： 1）必须下载特定的客户端程序。 2）服务器端升级，客户端升级。 B/S （Broswer -Server 浏览器端- 服务器端） 典型应用： 腾讯官方（www.qq.com） 163新闻网站， 蚂蚁课堂官网（俗称：网站） 特点： 1）不需要安装特定的...
快速入门Java并发编程与多线程实战
Java进阶课程之并发编程快速入门与多线程实战项目包括了CPU调度算法原理、线程安全问题分析、Callable与FutureTask模式手写以及并发队列日志框架实战案例等内容。在这门课程中，学员将深入了解到多线程技术的基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值