线程相关知识点总结

最新推荐文章于 2022-11-27 11:18:12 发布
最新推荐文章于 2022-11-27 11:18:12 发布
阅读量164 收藏 1
点赞数 1
文章标签： 线程通信 线程生命周期
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Biaoooos/article/details/90137884
版权
1.线程的启动方式

开启主要有两种：继承Thread和实现cannable接口；

  • 继承Thread：
public class Practice {
	public static void main(String[] args) {
//	继承 Thread  任务：copy文件
		Copy c = new Copy();
		c.start();
		}
}
class Copy extends Thread{
	@Override
	public void run() {
		File filename = new File("a.txt");
		File copyname = new File("copy.txt");
		try {
			copyFile(filename,copyname );
			System.out.println("复制成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}		
	private void copyFile(File fileName,File copyName) throws Exception {
		FileInputStream fis = new FileInputStream(fileName);
		FileOutputStream fos = new FileOutputStream(copyName);
		int len = 0;
		byte[] byt= new byte[1024];
		while ((len=fis.read(byt))!=-1) {
			fos.write(byt, 0, len);
			fos.flush();			
		}
		fis.close();
		fos.close();		
	}
}
  • 实现cannable接口：
public class Practice {
	public static void main(String[] args) {
//	实现runnable 任务：输出任意范围字母
		Print p= new Print();
		Thread thread = new Thread(p);
		thread.start();
		}
}
class Print implements Runnable{
	@Override
	public void run() {
		int a = (int) (Math.random()*26+97);
		int b = (int) (Math.random()*26+97);
		if (a>=b) {
			for (int i = b; i <= a; i++) {
				System.out.print("实现Runable"+(char)i+"  ");
			}
		}else if (a<b) {
			for (int i = a; i <= b; i++) {
				System.out.print("实现Runable"+(char)i+"  ");
			}
		}
	}	
}
2.线程的生命周期

在这里插入图片描述

3.线程池
  • 线程池的开启:

Executors 工厂类来产生线程池。
构造方法
public static ExecutorService newCachedThreadPool()
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newSingleThreadExecutor()

 */
public class ThreadDemo01 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(3);
		// 将线程放入到池中
		pool.submit(new MyRunnable());
		Future<Integer> future = pool.submit(new MyCallable());
		pool.submit(new Runnable() {			
			@Override
			public void run() {
				for (int i = 0; i < 100; i++) {
					System.out.println(Thread.currentThread().getName() + "线程池匿名内部类实现Runnable方式开启线程:" + i);
				}
			}
		});
		System.out.println("1~100的和为:" + future.get());		
		// 结束线程池
		pool.shutdown();
	}
}

class MyRunnable implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + "线程池实现Runnable方式开启线程:" + i);
		}
	}	
}

class MyCallable implements Callable<Integer> {
	@Override
	public Integer call() throws Exception {		
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			System.out.println(Thread.currentThread().getName() + "线程池实现Callable方式开启线程:" + i);
			sum += i;
		}
		return sum;
	}	
}
4.线程同步
5.线程通信：
  • 通过构造方法 A -> B A在启动之前传递给B
  • 通过实现Callable接口的方式 A -> B B在执行结束之后将数据回传给A
  • 利用接口回调方式传递数据
  • 利用同步锁串行实现数据传递
  • 利用等待唤醒机制
    下面主要解释下后三种方法：
    （1.）接口回调
    1.创建一个回调接口[电话号码],接口中书写方法 A->B
    方法的形参就是 B线程使用形参传递给A线程
    方法的返回值就是 A线程使用返回值传递给B线程
    2.A线程将这个回调接口通过构造方法传递给B线程
    3.B线程在使用这个接口,即接口回调
 public class Test {
	public static void main(String[] args) {
		BThread thread = new BThread("B", new ICallBack() {			
			@Override
			public String fun(int a, int b, String message) {
				int sum = a + b;
				System.out.println("收到了来自于B线程的消息: " + message);
				return sum + ":" + BThread.currentThread().getName();
			}
		});
		thread.start();		
	}
}

class AThread extends Thread {
	@Override
	public void run() {
	}
}
class BThread extends Thread {	
	private ICallBack cb;	
	public BThread() {}	
	public BThread(String name, ICallBack cb) {
		super(name);
		this.cb = cb;
	}
	public void setCb(ICallBack cb) {
		this.cb = cb;
	}
	public void run() {
		String result = cb.fun(10, 20, "我是线程B带过来两个整数数据");
		System.out.println("收到了来自于A线程的数据: " + result);
	}	
}
// 回调接口
interface ICallBack {
	String fun(int a, int b, String message);
}

（2.）利用同步锁串行实现数据传递

public class Test9 {
	public static void main(String[] args) {
		MyObject object =new MyObject();
//		三个线程共享一个锁对象
		MythreadA ma = new MythreadA(object);
		MythreadB mb = new MythreadB(object);
		MythreadC mc = new MythreadC(object);
		ma.start();
		mb.start();
		mc.start();
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println(object.getCount());
	}
}

class MythreadA extends Thread {
	private MyObject object;
	public void run() {
		object.methodA("A");
		System.out.println("ma执行完后count为"+object.getCount());
	};
	public MythreadA() {
	}
	public MythreadA(MyObject object) {
		this.object = object;
	}
	public Object getObject() {
		return object;
	}
	public void setObject(MyObject object) {
		this.object = object;
	}

}

class MythreadB extends Thread {
	private MyObject object;
	public void run() {
		object.methodB("B");
		System.out.println("mb执行完后count为"+object.getCount());
	};
	public MythreadB() {
	}
	public MythreadB(MyObject object) {
		this.object = object;
	}
	public Object getObject() {
		return object;
	}
	public void setObject(MyObject object) {
		this.object = object;
	}
}

class MythreadC extends Thread {
	private MyObject object;
	public void run() {
		object.methodC("C");
		System.out.println("mc执行完后count为"+object.getCount());
	};
	public MythreadC() {
	}
	public MythreadC(MyObject object) {
		this.object = object;
	}
	public Object getObject() {
		return object;
	}
	public void setObject(MyObject object) {
		this.object = object;
	}
}
//自定义锁对象
class MyObject {
	private String count = "";
	public MyObject() {

	}
//同步方法的锁对象是this(为调用者),由于调用的对象为同一对象object，因此锁对象一样。
	public synchronized void methodA(String message) {
		System.out.println(message);
		count += message;
	}

	public synchronized void methodB(String message) {
		System.out.println(message);
		count += message;
	}

	public synchronized void methodC(String message) {
		System.out.println(message);
		count += message;
	}

	public MyObject(String count) {
		this.count = count;
	}
	public String getCount() {
		return count;
	}
	public void setCount(String count) {
		this.count = count;
	}
	@Override
	public String toString() {
		return "Object [count=" + count + "]";
	}	
}

（3.）利用等待唤醒机制
wait(),notify(),notifyll()
生产者消费者模型:

//共享资源
public class Toy {
	private String name; // 玩具名称
	private int num; // 玩具数量
	private boolean flag; // 是否有玩具, 有表示true,没有表示false
	public Toy() {
		super();
	}
	public Toy(String name, int num, boolean flag) {
		super();
		this.name = name;
		this.num = num;
		this.flag = flag;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
	public boolean isFlag() {
		return flag;
	}
	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	@Override
	public String toString() {
		return "Toy [name=" + name + ", num=" + num + ", flag=" + flag + "]";
	}
}
//消费者线程
public class GetThread extends Thread {
	private Toy t;
	public GetThread() {
	}
	public GetThread(Toy t) {
		this.setT(t);
	}	
	@Override
	public void run() {		
		while (true) {
			synchronized (t) {
				// 先判断是否有玩具
				if (!t.isFlag()) {
					// 没有,就等待生产者生产
					try {
						t.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}				
				// 有,就消费
				String toyName = t.getName();
				int toyNum = t.getNum();
				System.out.println(toyName + "|" + toyNum);
				// 消费一次数量减一
				t.setNum(--toyNum);				
				// 消费完毕之后,就通知生产者生产
				if (toyNum <= 0) {
					// 设置标志位,说明没有玩具了
					t.setFlag(false);
					// 消费完毕之后,就通知生产者生产
					t.notify();
				}
			}
		}		
	}
	public Toy getT() {
		return t;
	}
	public void setT(Toy t) {
		this.t = t;
	}		
}
//生产者线程
public class SetThread extends Thread {
	private Toy t;
	private int i;
	public SetThread() {
		super();
	}
	public SetThread(Toy t) {
		super();
		this.t = t;
	}	
	@Override
	public void run() {
		while (true) {
			synchronized (t) {
				// 先判断是否有玩具
				if (t.isFlag()) {
					// 就等待消费者消费
					try {
						t.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}				
				// 没有,就生产
				if (i % 2 == 0) {
					t.setName("Hello Kitty");
					t.setNum(10);
				} else {
					t.setName("King");
					t.setNum(5);
				}
				i++;				
				// 设置标志位,表示目前已经有数据了
				t.setFlag(true);				
				// 生产完毕之后通知消费者消费  nofity
				t.notify();
			}
		}		
	}
	public Toy getT() {
		return t;
	}
	public void setT(Toy t) {
		this.t = t;
	}	
}
//主线程
public class ThreadDemo01 {
	public static void main(String[] args) {
		Toy t = new Toy();		
		SetThread st = new SetThread(t);
		GetThread gt = new GetThread(t);		
		st.start();
		gt.start();
	}
}
Biaoooos
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java笔记 - 线程基础知识
yansha的专栏
04-05 4444
进程是一个执行中程序的实例，是操作系统进行资源分配和调度的一个独立单元。线程是进程中一个单一的程序控制流，是 CPU 调度和分派的基本单元。进程在执行时拥有独立的内存空间，进程中的线程可以共享进程的内存空间。在 Java 的世界中，进程可以拥有多个并发执行的线程，多线程是实现并发任务的方式。
关于线程知识详细总结
freeherotoday的博客
11-08 895
是为了建立程序单独的执行路径，让多部分代码实现同时执行——并发执行。
线程相关知识点
qq_45792764的博客
08-09 262
线程相关知识点
线程基本知识总结
weixin_44431128的博客
11-27 324
线程是调度的基本单位，状态是针对当前的线程调度的情况来描述的，因此状态 是线程的属性。 在Java中对于线程的状态有： 1. new：创建了Thread对象，但是还没有调用start（就是说内核里还没有创建对应的PCB） 2. terminated：终止。表示内核的PCB已经执行完毕，但是Thread对象还在 3. runnable：可运行的 - 正在CPU上执行的 - 在就绪队列中，随时可以去CPU上执行的 4. waiting： 5. timed_waiting： 6. blo
必必须掌握的线程知识点
最大努力的博客
08-06 1074
java中可有两种方式实现多线程，一种是继承Thread类，一种是实现Runnable接口 Thread类是在java.lang包中定义的，一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限 详见：http://developer.51cto.com/art/201203/321042.htm 知识点一、实现自定...
Java多线程-多线程知识点总结和企业真题
最新发布
02-04
Java多线程--多线程知识点总结和企业真题
Java多线程知识点总结
08-19
该文档总结了Java多线程相关的知识点，分享给大家，简单易懂！
python进程和线程用法知识点总结
09-19
在本篇文章里小编给大家整理了关于python进程和线程用法以及相关实例内容，需要的朋友们跟着学习下。
python3多线程知识点总结
12-31
多线程类似于同时执行多个不同程序，多线程运行有如下优点： 使用线程可以把占据长时间的程序中的任务放到后台去处理。 用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来...
java线程相关知识点整理
AmyXia
03-16 287
1、创建新线程实例： Extends Thread类并重写run方法，创建这个类的实例即可； 或者创建一个类，实现Runnable接口，实现run方法，通过将这个类的实例传入Thread的构造器来创建一个Thread实例，这实例调用start方法时，这个实现类实现的run方法会在这个单独运行中的线程种被自动调用。 两种方法的比较：实现runnable接口更适合于if you are only...
多线程基础知识
weixin_43897440的博客
03-22 261
多线程基础知识
有关线程的相关知识（上）
热门推荐
顾林海
04-17 2万+
前言一系列任务的同时运行称之为并发，可以认为是多个任务交替执行，并且多个任务之间有可能还是串行的，与并发相关的另一个概念是并行，并行是真正意义上的“同时执行”。线程的两种创建方式我们在Java中创建线程可以通过以下两种方式来创建： 继承Thread类，并且覆盖run()方法。 创建一个实现Runnable接口的类，使用带参数的Thread构造器来创建Thread对象。 接下来看看以下程序：publi
线程知识点
m0_58103348的博客
07-16 130
java线程
java线程知识点汇总
jerryq的博客
02-20 3287
线程状态        线程的状态可以分为5种：新建new、可运行runnable、正在运行running、阻塞blocked和死亡dead。        新建new：当一个线程新建出来，例如 Thread thread = new Thread() 此时，线程状态就是new。        可运行Runnable：当新建的线程调用start方法，线程状态就变为runnable，此时线...
【Java篇】线程知识点总结
m0_64231944的博客
04-09 1146
(超全)线程知识点、及线程方面的一些理解性问题
java多线程知识点整理
小柒木有熙
10-23 2945
java多线程知识点整理State枚举类 下面详细说明一下线程各状态表示的意思: NEW：至今尚未启动的线程处于该状态，通俗来讲，该状态是线程实例化后还从未执行start()方法的状态； RUNNABLE:正在java虚拟机中执行的线程处于这种状态； BLOCKED:受阻塞并等待某个监视器锁的线程处于这种状态； WAITING:无限期地等待另一个线程来执行某一特定操作的线程处于这种状态； TIME
多线程相关知识整理
zhouym_的博客
05-10 589
进程 先来了解下什么是进程 进程：指正在运行的程序，例如：QQ,微信，浏览器等等 进程有前台进程，后台进程 一个进程可以有一条线程，也可以有多条线程 线程 线程：具有完成独立任务的一条执行路径 public class Thread extends Object implements Runnable 线程是程序中的执行线程。Java虚拟机允许应用程序并发的运行多个执行线程 每个线程都有一个...
那些年搞不懂的多线程、同步异步及阻塞和非阻塞（一）---多线程简介
weixin_30709061的博客
08-08 286
1、进程和线程的概念 进程：运行中的应用程序称为进程，拥有系统资源（cpu、内存） 线程：进程中的一段代码，一个进程中可以有多段代码。本身不拥有资源（共享所在进程的资源）； 在java中，程序入口被自动创建为主线程，在主线程中可以创建多个子线程。 区别： 1、是否占有资源问题 2、创建或撤销一个进程所需要的开销比创建或撤销一个线程所需要的开销大。 3、进程为重量级组件，线程为轻...
多线程相关知识点详解
weixin_38203902的博客
03-27 332
一:初识线程并发(模拟并发情况下计数器结果) /** - @Author: 小土狗 - @Date: 2019/3/27 15:14 - @Version 1.0 */ public class DownloadSample { //模拟并发用户数 private static int user = 1; //模拟下载总数 private static in...
关于c++的知识点总结
02-22
C 语言是一种通用的、面向过程的...它的主要特点有：支持面向过程的编程，支持复杂的数据结构，支持多种编程范式，支持大量的编程库，支持跨平台编程，支持多态，支持运行时类型检查，支持可移植性，支持多线程编程等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值