Java基础~进程和线程

已于 2022-08-17 19:49:17 修改
阅读量81 收藏
点赞数 3
分类专栏： 进程和线程 Java 文章标签： java 开发语言 eclipse
于 2022-08-16 06:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51222096/article/details/126353788
版权

目录

进程中线程之间的关系

截图：

进程和线程的关系

 线程和进程的区别[面]

 创建线程的4种方法：

1、继承Thread

 运行截图：

2、实现Runnable接口

运行截图：​编辑 

3、使用Callable和Future接口创建线程

 运行截图：

4、线程池

线程池的好处

 运行截图：

常见问题总结

进程中线程之间的关系


 * 线程不像进程，一个进程中的线程之间是没有父子之分的，都是平级关系。
 * 即线程都是一样的, 退出了一个不会影响另外一个。但是所谓的主线程
 * main可以在执行完处理逻辑后调用System.exit()。exit会让整个进程
 * over终止，那所有线程自然都会退出。

package com.yan;

public class Test1 {
public static void main(String[] args) {
	System.out.println("开始执行");
	Thread t=Thread.currentThread();
	System.out.println(t);  //Thread[main,5,main]
	Test1 t2=new Test1();
	t2.cc();
	System.out.println("结束执行");
}
public void cc() {
	System.out.println("开始执行cc");
	Thread t=Thread.currentThread();
	System.out.println(t);  //Thread[main,5,main]
	System.out.println("结束执行cc");
}
}

截图：

 

进程和线程的关系


 1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（主线程）。
 2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。
 3、线程在执行过程中需要协作同步。
 4、CPU分给线程，即真正在处理机上运行的是线程。
 5、线程是指进程内的一个执行单元，也是进程内的可调度实体，两者都是动态的概念。
 

 线程和进程的区别[面]


 * - 调度：线程是CPU调度和分配的基本单位，进程是系统资源分配和调度的基本单位。
 * - 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行，
 * 一个进程至少有一个线程（单进程单线程），一个线程必须隶属于某个进程。
 * - 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。
 * 进程和线程最大的区别在于：进程是由操作系统来控制的，而线程是由进程来控制的。
 * - 线程本身的数据通常只有寄存器数据，以及一个程序执行时使用的堆栈，所以线程的切换比进程切换的负担要小
 * - 多个进程的内部数据和状态都是完全独立的，而多线程是共享一块内存空间和一组系统资源，有可能互相影响 

线程多次运行得结果执行顺序不一定相同，这就是多线程运行过程得不可重现性（执行顺序不能保证）运行结果应该是一致的

package com.yan2;

import java.util.concurrent.Semaphore;

/*
 * 多次运行会发现执行顺序不一定相同，这就是多线程运行过程的不可重现性
 * （执行的顺序不能保证），运行结果应该是一致的
 * 
 * Semaphore
 */
public class Test1 {
	public static void main(String[] args) {
		//创建线程对象，然后调用start方法则可以启动一个线程，运行的代码就是run方法中的代码
		Thread t1 = new Thread() {
			public void run() {
				for(int i=0;i<10;i++) {
					System.out.println("左手一个慢动作");
					try {
						Thread.sleep(200);  //使当前线程休眠200ms
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		};
		Thread t2 = new MyThread();
		t1.start();
		t2.start();
	}
}

class MyThread extends Thread {
	@Override
	public void run() {
		for(int i=0;i<10;i++) {
			System.out.println("右手慢动作重播");
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 创建线程的4种方法：

1、继承Thread

调用线程对象的start方法启动线程，不能直接调用run方法，否则是单线程Java采用的是单根继承体系，所以一旦继承于Thread类，则不能继承其它类

public class Test1 {
public static void main(String[] args) {
	System.out.println(Thread.currentThread()); //获取当前线程对象
	//方法1.2
	Thread t2=new Thread() {
		@Override
		public void run() {
			for(int i=0;i<50;i++) {
				System.out.println("右手慢动作重播"+Thread.currentThread());
				try {
					Thread.sleep(150);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	};
//	t2.run();
	Thread t1=new MyThread3();
	t1.start();
	t2.start();
}
}

//方法1.1
class MyThread3 extends Thread{
	@Override
	public void run() {
		for(int i=0;i<50;i++) {
			System.out.println("左手一个慢动作"+Thread.currentThread());
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 运行截图：

2、实现Runnable接口

源代码@FunctionalInterface   注解声明是函数式接口
 public interface Runnable {
          public abstract void run();
 }
 问题：定义run()方法没有返回值

public class Test2 {
	public static void main(String[] args) {
		Thread t1 = new Thread(new MyRunnable());
		t1.start();
		// 方法2.2
		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 10; i++) {
					System.out.println("中间手...."+Thread.currentThread());
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}).start();
		// 方法2.3
		new Thread(() -> {
			for (int i = 0; i < 10; i++) {
				System.out.println("右手...."+Thread.currentThread());
				try {
					Thread.sleep(100);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
}

//方法2.1
class MyRunnable implements Runnable {
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("左手...."+Thread.currentThread());
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}

运行截图： 

3、使用Callable和Future接口创建线程

具体是创建Callable接口的实现类，并实现call()方法。并使用FutureTask类来包装
Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程 
  java.util.concurrent.Callable  有时java.util.concurrent包可以称为juc包
 @FunctionalInterface  注解用于声明当前接口是一个函数式接口
 public interface Callable<V> {  这里<>中用于声明返回值的类型
   V call() throws Exception;  真正执行的方法，有返回值，允许抛出异常
 }
 
 线程的构造器为
 public Thread(Runnable target) {
        this(null, target, "Thread-" + nextThreadNum(), 0);
    }
    
    Future接口
    public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);  可以取消正在运行的线程
    boolean isCancelled(); 判断是否取消
    boolean isDone(); 判断线程是否在运行中
    V get() throws InterruptedException, ExecutionException; 获取线程执行的结果
    V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;

    Java针对Future接口提供的具体实现类FutureTask
     源代码:
    public class FutureTask<V> implements RunnableFuture<V>
    
    public interface RunnableFuture<V> extends Runnable, Future<V>
    
    构造器
      public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    
    public void run() {
            Callable<V> c = callable;
            ...
                    result = c.call();
    }

public class Test3 {
	public static void main(String[] args) throws Exception {
		// 为了获取返回值，所以需要使用FutureTask中提供的get方法
		FutureTask<Integer>[] arr = new FutureTask[10];
		for (int i = 1; i <= 10; i++) {
			int begin = (i - 1) * 100 + 1;
			int end = i * 100;
			// 定义Callable的实现
			Callable<Integer> c = new Callable<Integer>() {
				public Integer call() throws Exception {
					int res = 0;
					for (int k = begin; k <= end; k++)
						res += k;
					return res;
				}
			};
			// 构建FutureTask对象，其中包含Callable对象
			FutureTask<Integer> ft = new FutureTask<>(c);
			// 不是必须的，只是证明FutureTask实现了Runnable接口
			Runnable r = ft;
			arr[i - 1] = ft;
			// 启动线程，构建Thread对象时，要求参数类型为Runnable接口类型
			// 线程执行时会自动调用run方法，而FutureTask中提供的run方法会调用Callable对象的call方法
			new Thread(r).start();
		}
		int res = 0;
		for (FutureTask<Integer> tmp : arr)
			res += tmp.get(); // main线程执行到这里时，会自动阻塞等待子线程tmp执行结束，执行结束后获取call方法的返回值
		System.out.println(res);
	}
}
//注意:FutureTask实现了Future和Runnable接口，所以new Thread(futureTask),
// 当执行thread.start()方法时会自动调用Callable接口实现中的call方法。当调用
//futureTask.get()方法时可以获取对应的线程对象的执行结果，如果线程并没有返 回时，当前线程阻塞等待

 运行截图：

4、线程池

线程池的好处

 重用存在的线程，减少对象创建、消亡的开销，性能佳可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞提供定时执行、定期执行、单线程、并发数控制等功能。

使用线程池创建线程
享元模式Flyweight Pattern主要用于减少创建对象的数量，以减少内存占用和提高性能
这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象
 结构的方式
 优点：大大减少对象的创建，降低系统内存的使用，以提高程序的执行效率。
 缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化
 的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。

public class Test4 {
public static void main(String[] args)throws Exception {
	for(int i=0;i<100;i++) {
		IShape tmp=ObjectManager.getInstance();
		System.out.println(tmp);
		ObjectManager.releaseInstance(tmp);
	}
}
}

interface IShape {
	public void draw();
}

class Circle implements IShape {
	public void draw() {
		System.out.println("绘制一个圆形");
	}
}
//共享所有的IShape类型的对象，当需要使用IShape对象时，从对象池中获取一个即可
//，不是临时创建；当不需要使用对象时，不是直接释放对象，而是归还对象池
class ObjectManager {
	private static IShape[] arr = new IShape[20];
	static { // 类加载完毕，则在对象池中已经准备好了20个对象
		for (int i = 0; i < arr.length; i++)
			arr[i] = new Circle();
	}

	// 当需要使用对象时，从对象池中获取一个对象即可
	public static IShape getInstance() {
		IShape res = null;
		for (int i = arr.length - 1; i >= 0; i--) {
			res = arr[i];
			if (res != null) {
				arr[i] = null;
				break;
			}
		}
		return res;
	}

	// 当不使用对象时，需要归还到对象池中，以供下次需要时再次使用
	public static void releaseInstance(IShape obj) {
		for (int i = 0; i < arr.length; i++) {
			IShape tmp = arr[i];
			if (tmp == null) {
				arr[i] = obj;
				break;
			}
		}
	}
}

 运行截图：

常见问题总结


 一般创建线程对象时不建议使用extends Thread方法？ 单根继承
 一般没有返回结果时建议使用Runnable接口，如果有返回值一般建议使用Callable接口如果使用线程比较频繁建议使用线程池

码&
关注
专栏目录
Java中的进程和线程（*）
weixin_42408447的博客
11-30 729
1.前言 我们都知道计算机的核心是CPU，它承担了所有的计算任务，而操作系统是计算机的管理者，它负责任务的调度，资源的分配和管理，统领整个计算机硬件；应用程序是具有某种功能的程序，程序是运行在操作系统之上的。 2.进程的理解 （1）什么是进程 一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。 由图可知，谷歌浏览器正在运行16个进程，IDEA正在运行9个进程，每一个.exe文件就是一个进程，每个进程对应
Java的进程与线程
zzobin的专栏
12-16 1万+
进程是什么？进程是程序执行的一个实例，比如说，10个用户同时执行IE，那么就有10个独立的进程(尽管他们共享同一个可执行代码)。             进程不是什么？一个没有运行的程序不是一个进程。             进程的特点：每一个进程都有自己的独立的一块内存空间、一组资源系统。其内部数据和状态都是完全独立的。             怎么看待进程？进程的优点是提高CPU运行效率
进程和线程
qq_45874107的博客
02-07 1309
进程和线程的关系 1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（主线程）。 2、资源分配给进程，同一进程的所有线程共享该进程的所有资源。 3、线程在执行过程中需要协作同步。 4、CPU分给线程，即真正在处理机上运行的是线程。 5、线程是指进程内的一个执行单元，也是进程内的可调度实体，两者都是动态的概念。 线程和进程的区别 调度：线程是CPU调度和分配的基本单位，进程是系统资源分配和调度的基本单位。 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行，一个进
进程与线程
热门推荐
whwjn的专栏
04-20 2万+
进程与线程进程和线程是两个相对的概念，通常来说，一个进程可以定义程序的一个实例（Instance）。在Win32中，进程并不执行什么，它只是占据应用程序所使用的地址空间。为了让进程完成一定的工作，进程必须至少占有一个线程，正是这个线程负责包含进程地址空间中的代码。实际上，一个进程可以包含几个线程，它们可以同时执行进程地址空间中的代码。为了做到这一点，每个线程有自己的一组CPU寄存器和堆栈。每个进程
【java】进程和线程
qq_57420582的博客
07-06 302
进程和线程
Java并发编程进程和线程之由来Java开发Java经验技
11-22
Java并发编程是Java开发中的重要领域，涉及到进程与线程的概念，这两个概念是理解多任务执行的基础。在现代计算机系统中，进程和线程被广泛用于实现高效的资源管理和任务调度。 **1. 进程** 进程是操作系统分配...
java线程和进程的区别_Java中的线程和进程比较
weixin_33406440的博客
02-17 2573
1.进程和线程的区别通俗一点说，进程就是程序的一次执行，而线程可以理解为进程中的执行的一段程序片段。用一点文词说就是，每个进程都有独立的代码和数据空间(进程上下文);而线程可以看成是轻量级的进程。一般来讲(不使用特殊技术)，同一进程所产生的线程共享同一块内存空间。同一进程中的两段代码是不可能同时执行的，除非引入线程。线程是属于进程的，当进程退出时该进程所产生的线程都会被强制退出并清除。线程占用的资...
java 线程详解及线程与进程的区别
08-31
Java线程详解与进程的区别是...了解线程与进程的区别以及如何在Java中创建和管理线程，对于开发高效、健壮的多线程应用至关重要。正确地处理线程同步和通信可以避免死锁、活锁和饥饿等问题，确保程序的稳定性和正确性。
简述Java中进程与线程的关系_动力节点Java学院整理
08-30
本文将简单介绍如何使用这些类来创建进程和线程，并着重介绍这些类是如何和操作系统本地进程线程相对应的。 进程和线程的关系 ---------------- 在 Java 语言中，对进程和线程的封装，分别提供了 Process 和 ...
JAVA中的进程和线程
qq_36074113的博客
07-09 453
一：进程与线程 概述：几乎任何的操作系统都支持运行多个任务，通常一个任务就是一个程序，而一个程序就是一个进程。当一个进程运行时，内部可能包括多个顺序执行流，每个顺序执行流就是一个线程。   进程：进程是指处于运行过程中的程序，并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位。当程序进入内存运行时，即为进程。   进程的三个特点： 1：独立性：进程是系统中独立存在的实体，它
java中的进程和线程
qq_52772669的博客
05-13 225
1.进程1.进程在java中每运行一个程序就会产生一个进程进程的名字就是程序名称。使用while循环使程序能够不断运行。使用javac 编译java程序使用java 命令执行java程序不关闭程序执行界面，再次打开一个命令行窗口使用jps命令查看正在运行的进程。
Java中的进程和线程
weixin_37580466的博客
04-25 243
进程和线程 进程 进程是程序执行的一个实例，有独立的内存空间和系统资源 多个进程可以在CPU上并法执行，但是，同一时间CPU只能运行一个进程，其他进程处于非运行状态，所以多个进程在 CPU上并发执行，实质上是CPU来回切换执行多个进程 线程 如果把进程比作工厂车间的一条生产线，那么线程就是生产线上负责各个工序的工人。 一个进程可以拥有多个线程，但一个进程只能拥有一个主线程。当其他线程需要中途终止时...
java 进程和线程
weixin_45003321的博客
04-14 107
进程和线程 参考文章：https://www.cnblogs.com/java1024/archive/2019/11/28/11950129.html 什么是进程 进程是程序的一次动态执行过程，它需要经历：代码加载，代码执行，代码结束的完整的过程。也是一个过程从产生，发展到最终消亡的过程。 多进程操作系统是能够运行多个进程（程序），CPU具有分时机制，每个进程都能循环获得自己的CPU时间片，由于CPU执行速度非常快，使得所有的程序都好像是同时进行一样。 什么是线程 线程和进程一样，都是实现并发的一个基本单
Java进程和线程
zjh0101的博客
08-15 263
内存泄漏：特定的编程错误会导致你的应用程序不停的消耗更多的内存，每次使用有内存泄漏 风险的功能就会留下一些不能被回收的对象到堆空间中，随着时间的推移，泄漏对象会消耗所 有的堆空间，最终触发java.lang.OutOfMemoryError: Java heap space错误。十一，创建线程要花费昂贵的资源和时间，如果任务来了才创建线程那么响应时间会变长，而且一个进程能创建的线程数有限。* 僵尸进程是当子进程比父进程先结束，而父进程又没有回收子进程，释放子进程占用的资源，...
JAVA进程和线程
最新发布
程序猿追的博客
11-06 9191
进程就是正在运行的程序，它是系统资源调度的独立单位，并且一个进程可以执行多个任务，而线程就是程序执行的任务，它是程序使用CPU的基本单位，因此也可以说线程是依赖于进程的。像比如任务管理器里面的运行任务就是线程。
Java进程与线程创建及封装详解
4. **Java进程与本地进程线程的对应关系**： Java进程在内部实际上是通过调用操作系统提供的API来创建和管理的。Java进程和本地进程之间存在映射关系，但Java的封装隐藏了底层的复杂性，使得开发者无需直接与操作...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值