java多线程入门学习（一）

最新推荐文章于 2023-01-13 09:22:53 发布
原创 最新推荐文章于 2023-01-13 09:22:53 发布 · 1.5k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍Java多线程的基础概念，包括进程与线程的区别、线程生命周期等，并通过实例演示如何通过继承Thread类和实现Runnable接口来创建多线程。


java多线程入门学习（一）

一.java多线程之前

           进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1--n个线程。

　　    线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。

　　    线程和进程一样分为五个阶段：创建、就绪、运行、阻塞、终止。

　　    多进程是指操作系统能同时运行多个任务（程序）。

　　    多线程是指在同一程序中有多个顺序流在执行。

           在java中要想实现多线程，有两种手段，一种是继承Thread类，另外一种是实现Runnable接口，为什么会有两种方式，原因是由于java具有单继承性质，当有些类已经实现继承，但需要多线程时，我们给它另外一种办法，实现Runnable接口

二.继承Thread类

          在学习如何创建新的线程以前，首先让我们看下Thread类的结构：
public class Thread implements Runnable
        从上面的源码中可以发现Thread类实现了Runnable接口，它们之间是多态的关系。
        
        以下开始写代码，继承Thread类，我们在run()方法中写线程要执行的任务代码： 
package cn.sun.thread;
 
public class MyThread extends Thread{
 
	@Override
	public void run() {
		super.run();
		System.out.println("this is my first Thread : MyThread");
	}
	
}
        测试类如下，虽然我们复写的是run()方法，但是执行的却是start()方法：
package cn.sun.test;
 
import cn.sun.thread.MyThread;
 
public class ThreadTest01 {
	
	public static void main(String[] args) {
		
		MyThread mythread = new MyThread();
		mythread.start();
		System.out.println("program over");
	}
 
}
        从下面执行结果来看，可以知道使用多线程时代码的运行结构与代码执行顺序无关：
program over 
this is my first Thread : MyThread

        上面介绍了线程调用的随机性，下面这个例子将展示线程的随机性：
package cn.sun.thread;
 
public class MyThread extends Thread{
 
	@Override
	public void run() {
		try {
			
			for(int i=0; i<10; i++){
				int time = (int) (Math.random()*1000);
				Thread.sleep(time);
				System.out.println("run="+Thread.currentThread().getName());
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
}

package cn.sun.thread;
 
public class MyThreadTest02 {
	
	public static void main(String[] args) {
		
		try {
			
			MyThread thread = new MyThread();
			thread.setName("myThread");
			thread.start();
			for(int i=0; i<10; i++){
				int time = (int) (Math.random()*1000);
				Thread.sleep(time);
				System.out.println("run="+Thread.currentThread().getName());
			}
		} catch (Exception e) {
			e.printStackTrace(); 
		}
	}
}
结果如下：
run main
run MyThread
run main
run main
run MyThread
run MyThread
run main
run MyThread
run main
run main
run MyThread
run main
run MyThread
run MyThread
run MyThread
run main
run main
run MyThread
run main
run MyThread


        从上面就可以看出来线程的随机性，为什么会出现这种形式（随机性），主要是因为我们执行的是它的start()方法，当执行start()时将通知“线程规划器”此线程已准备好，等待调用run()方法，也就是让系统安排一个时间去执行它，达到异步的效果，如果我们直接执行run()方法，则没有这种异步的效果，直接同步了，多线程亦没有了意义。
        有一点需要说明，当我们同时启动多个线程时，执行start()方法的顺序不代表线程启动的顺序，还是那句话，真正的执行依赖于系统所分配的时间片。

三.实现Runnable接口

此类的应用场景相信大家已经知道了，就是当某个类已经有一个父类时，无法再继承Thread类，我们就用Runnable接口去实现它
package cn.sun.runable;
 
public class MyRunnable implements Runnable{
 
	@Override
	public void run() {
		System.out.println("MyRunnable run...");
	}
 
}

package cn.sun.test;
 
import cn.sun.runable.MyRunnable;
 
public class MyRunnableTest01 {
	
	public static void main(String[] args) {
		Runnable runnable = new MyRunnable();
		Thread thread = new Thread(runnable);
		thread.start();
		System.out.println("main over...");
	}
 
}
结果如下：
main over...
MyRunnable run...


在上面的代码中，Thread thread =newThread(runnable);的代码不仅可以传入一个Runnable对象，还可以传入一个Thread类对象，这样做可以将一个Thread对象中的run()方法交给其他的线程进行调用。

三.实例变量的共享与私有

3.1 数据不共享形式：

package cn.sun.safe;
 
public class MyThread extends Thread {
	
	private int count = 5;
	public MyThread(String name){
		super();
		this.setName(name);
	}
	@Override
	public void run() {
		super.run();
		while(count > 0){
			count--;
			System.out.println(this.currentThread().getName()+"'s count is :" +count);
		}
	}
 
}

package cn.sun.test;
 
import cn.sun.safe.MyThread;
 
public class ThreadTest02 {
	
	public static void main(String[] args) {
		MyThread threadA = new MyThread("A");
		MyThread threadB = new MyThread("B");
		MyThread threadC = new MyThread("C");
		threadA.start();
		threadB.start();
		threadC.start();
		
	}
 
}
结果如下，各个实例对象的实例变量保持了私有，并没有共享：
A's count is :4
A's count is :3
A's count is :2
A's count is :1
A's count is :0
C's count is :4
C's count is :3
C's count is :2
B's count is :4
B's count is :3
B's count is :2
C's count is :1
C's count is :0
B's count is :1
B's count is :0

3.2 共享数据的情况

        上一个例子并不存在多个线程访问同一个实例变量的情况，这里我们试试三个线程对同一变量进行操作：

package cn.sun.safe;
 
public class MyThreadShare extends Thread {
	private int count = 5;
	
	@Override
	public void run() {
		super.run();
	    count--;
	    System.out.println(this.currentThread().getName()+"'s count is :" +count);


	}
 
}

package cn.sun.test;
 
import cn.sun.safe.MyThreadShare;
 
 
 
public class ThreadTest03 {
	public static void main(String[] args) {
		MyThreadShare myThread = new MyThreadShare();
		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();
	}
 
}
结果发现这样的情况：
B's count is :3
C's count is :2
A's count is :3
D's count is :1
E's count is :0

        当中的3产生了非线程安全问题，有两个线程打印出同样的数字，这样肯定是不行的，我们应该出现的效果是依次递减，而不是重复数字递减
        这里我们需要了解这样一个事情，在有些JVM中 i-- 的操作分为如下三步：
                (1)取得原有i的值
                (2)计算 i-1
                (3)对i进行赋值
        当多个线程同时进来访问时，肯定会出现非线程安全问题，我们将这个步骤用synchronized进行同步化就可以解决这个问题
package cn.sun.safe;
 
public class MyThreadShare extends Thread {
	private int count = 5;
	
	@Override
	synchronized public void run() {
		super.run();
		count--;
		System.out.println(this.currentThread().getName()+"'s count is :" +count);
	}
 
}
        这样之后运行结果就呈现这样的样子：
A's count is :4
C's count is :3
B's count is :2
E's count is :1
D's count is :0
        synchronized可以在任意对象及方法上加锁，加锁的这段代码称为“互斥区”或者“临界区”



Java中线程简单入门
xxyneymar的博客
09-15 238
1.线程是一个进程中的执行场景/执行单元，一个进程可以启动多个线程。比如以java为例，在DOS命令窗口运行一个java文件，此时会先启动JVM，而JVM就是一个进程，JVM会启动一个主线程调用main方法，同时再启动一个垃圾回收线程负责看护，回收垃圾，所以至少有两个线程并发。 两个进程之间的内存独立不共享，而属于同一进程的两个线程A、B会共享一定的资源，在java中，线程A和线程B共享堆内存和方法区内存，但是栈内存独立，一个线程一个栈，栈与栈之间互不干扰，各自执行各自的，这就是多线程并发。 ...
java线程的入门，十分详细，通俗易懂
weixin_43353498的博客
03-08 315
java多线程入门： 1.什么是进程和线程？ 进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位。系统运行一个程序即是一个进程从创建，运行到消亡的过程 线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。一个线程不能独立的存在，它必须是进程的一部分。 在有些操作...
多线程
weixin_43346634的博客
03-08 321
多线程基本概念：程序、进程、线程并行和并发使用多线程的优点何时需要多线程线程的创建和使用方式一：继承于Thread类Thread类当中的常用方法方式二：实现Runable接口线程的生命周期在Java中，我们通过同步机制，来解决线程的安全问题。方式一：同步代码块方式二：同步方法总结方式三：Lock锁 --- JDK5.0新增方式四：同步方法。 基本概念：程序、进程、线程 1. 程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 2.进程(process
java线程入门
a31081314的博客
05-18 264
package com.ailk.hostException.controller; import java.util.HashMap; import java.util.concurrent.ConcurrentHashMap; public class test { public static void main(String [] args){ HashMap&lt;Int...
Java线程的快速入门
目标架构师
04-15 404
Java线程的快速入门
java 线程入门_Java多线程入门
weixin_32384503的博客
02-21 119
如何创建和理解线程曾经在学习操作系统的时候，进程是一个重点内容，线程也学习过，但是没有什么深刻的印象。在Java多线程的学习中对线程有了一个全面而深刻的理解。一个进程可以包含一个或多个线程，一个线程就是一个程序内部的一条执行线索。创建多线程有两种方法：继承Thread类和实现Runnable接口。通过调用继承thread对象的start()方法就可以调用该类中的run()方法。如果想要将一段代码在...
Java多线程基础学习指南：原理、实现与实战
12-01
内容概要：本文详细介绍了Java多线程的基本概念、实现方式、线程控制方法、线程同步、线程池及其应用。首先解释了线程的概念及其优势，接着讲述了如何通过继承Thread类、实现Runnable接口和使用Callable接口来创建多...
头歌java多线程基础-Java多线程基础详解与实战指南
最新发布
12-01
内容概要：本文详细介绍了Java多线程的基础概念和关键技术点。首先解释了线程的基本概念、线程与进程的区别及其不同状态。接着，通过三种方式创建线程（继承Thread类、实现Runnable接口、使用Callable和Future接口）...
JAVA多线程入门基础知识
02-22
必知必会的多线程入门基础知识
java多线程学习
11-27
在学习Java多线程的过程中，理解线程与进程的概念是非常基础且重要的一步。首先，进程是一个程序的执行实例，是操作系统资源分配的基本单位，具有独立的地址空间和运行状态。每个进程至少包含一个线程，我们称之为...
汪文君JAVA多线程编程实战（完整不加密）
01-19
《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程，由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术，提升软件开发的效率和质量。在Java平台中，多线程是...
java线程入门（内附详细的开发环境讲解）
05-09
Java入门教程，供大家下载。里面有详细的代码，都是比较简单的，易懂，此外，还有详细的Java开发环境的教程，帮你熟悉它的基本环境，为以后打基础
Java多线程入门
rj2017211811的博客
10-20 282
进程和线程 进程是系统中正在运行的一个程序，程序一旦运行就是进程。进程是系统资源分配的基本单位。每个进程都有独立的地址空间，一个进程无法直接访问另一个进程的变量和数据结构。如果要让一个进程访问另一个进程的资源，需要使用进程间通信，如管道、文件、套接字等。 比如Windows系统中我们打开任务管理器查看到每个.exe文件，都是进程 线程是操作系统能够运算调度(CPU调度)的基本单位，线程被包含到进程中，是进程中的实际运作单位。一个进程就是进程中一条单一控制的顺序流。一个进程中有1-n个线程。一个进程中可以并
Java线程基础
weixin_40536930的博客
09-06 679
Java中线程的声明周期： Java线程中的状态 初始状态（New） 当线程对象创建后，则进入开启一个线程状态（Thread t = new MyThread();） 就绪状态（Runnable） 当调用线程对象的start()方法（t.start()），线程进入了就绪状态。处于就绪状态的线程，知识说明此线程已经做好了准备，随时等待CPU调度执行，并不是说明调用了start方法茨县丞...
java多线程入门（一）
青鸟飞鱼
08-08 810
1.java 进程与线程概念 现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。 线程是程序中一个单一的顺序控制流程.在单个程序中同时运行多个线程完成不同的工作,称...
java 多线程入门_java多线程入门---（一篇文章搞定）
weixin_26846533的博客
02-12 151
读前说明：由于是多线程编程，CPU调度线程的随机性，运行结果，每次都有可能不同，故在此没有截图程序的运行结果。读者可自行运行程序，检验结果。本文着重介绍java多线程编程的基础---耐心看完，就会有满满的收获多线程1.如果程序只有一条执行路径(main)，那么该程序就是单线程程序。2.如果程序有多条执行路径，那么该程序就是多线程程序。3.线程是依赖进程，而存在的。4.进程：就是正在运行的程序。5....
初学Java之线程基础
jmgufss的博客
07-25 301
一篇搞定线程基础提示以下是本篇文章正文内容，下面案例可供参考就是完成特定任务，用某种语言编写的一组指令的集合----->我们所写的代码。（1）进程就是指正在运行的程序，比如我们打开微信，使用微信时，就启动了一个进程。（2）进程是程序的一次执行的过程，是动态过程，它具有自己的产生、存在和消亡的过程。这就是一个个进程以上就是线程基础部分啦，欢迎大家讨论。...
java多线程入门（很到位）
weixin_45131680的博客
01-13 891
java中之所以有多线程机制，目的就是为了提高程序的处理效率。 对于单核的CPU来说，不能够做到真正的多线程并发，但是可以做到给人一种“多线程并发”的感觉。对于单核的CPU来说，在某一个时间点上实际上只能处理一件事情，但是由于CPU的处理速度极快，多个线程之间频繁切换执行，跟人来的感觉是多个事情同时在做。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值