Java线程初步

最新推荐文章于 2022-02-17 11:56:31 发布
最新推荐文章于 2022-02-17 11:56:31 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： Java 文章标签： Java 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_qiao/article/details/8948137
版权
  • 线程基本概念

线程是一个程序内部的顺序控制流，也可以将线程看做是一个程序中不同的执行路径。

  • 线程和进程的基本区别

进程可以看做是静态的，在一个程序执行之前，在内存中会生成这个进程的代码空间和数据空间，并且一个进程的代码空间和数据空间一般情况下是独占的，不和其他进程共享（如果不进行交互的话）；当这个程序开始执行，在这个进程中会产生一个主线程，然后这个主线程开始执行，如果有需要，这个主线程还会产生多个子线程并行执行，在宏观上看，这个进程开始执行了（实际上进程内部运行的是线程）。

  1. 进程有独立的代码和数据空间，而同一类线程共享代码段和数据空间，但是线程也有自己独立的运行栈和程序计数器（如果没有的话，线程并行运行起来就会出问题）。因此，进程间的相互切换的代价大于线程间的相互切换。
  2. 多线程和多进程：多线程是同一个程序中（同一类线程）多个不同的顺序流同时执行；多进程是操作系统中同时执行多个任务（程序）。

 

  • 如何产生一个并行执行的线程

一，继承Thread类

package hq.org;
public class TestThread1 extends Thread{
	private boolean flag = true;
	
	public static void main( String args[])
	{
		TestThread1 t = new TestThread1();
		t.start();
		for( int i=0; i<100; i++)
		{
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("I'm MainThread.");
		}
		t.endSubThread();
		System.out.println("MainThread Stoped.");
	}
	
	public void run()
	{
		while( this.flag )
		{
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("----I'm SubThread.");
		}
		System.out.println("----SubThread Stoped.");
	}
	
	public void endSubThread()
	{
		this.flag = false;
	}
}

二，实现runnable接口

package hq.org;

public class TestThread {
	public static void main(String args[])
	{
		Runner1 r = new Runner1();
		Thread t1 = new Thread( r );
		t1.start();               //开始子线程             
		for( int i=0; i<50; i++) //主线程
		{
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(i + "	I'm MainThread.");
		}
		r.endThread(); //停止子线程
	}
	
}

class Runner1 implements Runnable
{
	private boolean flag = true;  //标识线程是否运行
	@Override
	public void run() {   //重写run方法
		while( flag )
		{
			try {
				Thread.sleep(500);  
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("-------I'm SubThread.");
		}
	}
	
	public void endThread() { //使得线程停止
		this.flag = false;
	}
	
}

注意，这里对于产生一个新的进程，调用的都是start方法，要是直接调用run方法的话，那仅仅相当于调用某个方法，而不会产生一个新的进程去执行run方法。

除此之外，实现Runnable接口的方式比直接继承Thread类的方式要灵活。

 

  • sleep，join和yield方法

sleep方法：使线程暂停n个毫秒

join方法：线程1掉用线程2的join方法，线程1将暂停等待线程2执行完，然后再接着往下执行

yeild方法：让步方法，暂时让出一下占用到的时间片，供其他线程使用

测试Join方法：

package hq.org;

public class TestJoin {
	public static void main(String[] args) {
		MyThread2 t1 = new MyThread2("Thread 2");
		t1.start();
		for( int i=0; i<3; i++)
		{
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("i am main thread run with Thread2.");
		}
		try {
			t1.join();
		} catch (InterruptedException e) {
		}

	for (int i = 1; i <= 10; i++) {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("i am main thread run alone.");
	}
	}
}

class MyThread2 extends Thread {
	MyThread2(String s) {
		super(s);
	}

	public void run() {
		for (int i = 1; i <= 10; i++) {
			System.out.println("i am " + getName());
			try {
				sleep(1000);
			} catch (InterruptedException e) {
				return;
			}
		}
	}
}

测试yeild方法：

package hq.org;

public class TestYield {
	public static void main(String[] args) {
		MyThread3 t1 = new MyThread3("t1");
		MyThread3 t2 = new MyThread3("t2");
		t1.setPriority(1);
		t2.setPriority(5);
		t1.start();
		t2.start();
	}
}

class MyThread3 extends Thread {
	MyThread3(String s) {
		super(s);
	}

	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(getName() + ": " + i);
			if (i % 10 == 0) {
				yield();
			}
		}
	}
}

  • 线程同步
package hq.org;

public class TestSync implements Runnable {
	Timer timer = new Timer();

	public static void main(String[] args) {
		TestSync test = new TestSync();
		Thread t1 = new Thread(test);
		Thread t2 = new Thread(test);
		t1.setName("t1");
		t2.setName("t2");
		t1.start();
		t2.start();
	}

	public void run() {
		timer.add(Thread.currentThread().getName());
	}
}

class Timer {
	private static int num = 0;

	public void add(String name) {
	num++;
	try {
		Thread.sleep(1);
	} catch (InterruptedException e) {
	}
	System.out.println(name + ", 你是第" + num + "个使用timer的线程");
	}
}

不加synchronized关键字：


加synchronized关键字：


可能是打印不叫耗时，在一个线程对Timer对象里的num值自增1次后，还没来得及打印，另外一个线程又一次调用add方法，将num值再次增1，所以两次打印出来得结果都是2，如果要让这个程序合理的运行，可以对Timer类的add方法加上synchonized关键字修饰。

 

  • 一个简单的死锁
package hq.org;

public class TestDeadLock implements Runnable {
	public int flag = 1;
	//两个临界资源
	static Object o1 = new Object(), o2 = new Object();
	public void run() {
		System.out.println("线程" + flag + "启动。。。");
		if (flag == 1) {
			//线程1，锁住资源1
			synchronized (o1) {
				System.out.println("线程1，锁住资源1");
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				//线程1，锁住资源2
				synchronized (o2) {
					System.out.println("线程1，锁住资源2");
				}
				System.out.println("线程1结束。");
			}
			System.out.println("");
		}
		if (flag == 0) {
			//线程2，锁住资源2
			synchronized (o2) {
				System.out.println("线程2，锁住资源2");
				try {
					Thread.sleep(500);
				} catch (Exception e) {
					e.printStackTrace();
				}
				//线程2，锁住资源1
				synchronized (o1) {
					System.out.println("线程2，锁住资源1");
				}
				System.out.println("线程2结束。");
			}
		}
	}

	public static void main(String[] args) {
		TestDeadLock td1 = new TestDeadLock();
		TestDeadLock td2 = new TestDeadLock();
		td1.flag = 1;
		td2.flag = 0;
		Thread t1 = new Thread(td1);
		Thread t2 = new Thread(td2);
		t1.start();
		t2.start();

	}
}


死锁结构图：




  • 一个简单的生产者和消费者程序
package hq.org;

public class MyProducerConsumer {
	public static void main( String args[]){
		SynicStack synicStack = new SynicStack();
		Consummer cc = new Consummer(synicStack);
		Producer pp = new Producer(synicStack);
		Thread tc1 = new Thread( cc );
		Thread tc2 = new Thread( cc ); 
		Thread tp = new Thread( pp );
		tp.start();
		tc1.start();
		tc2.start();
	}
}

class SynicStack {
	private final int stackLen = 10;
	private int[] res = new int[stackLen];
	private int top = -1;

	public synchronized void push(int res) {
		while (stackLen-1 == top) {
			// 如果栈满，等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		top++;
		this.res[top] = res;
		// 唤醒其他进程
		this.notifyAll();
		System.out.println("------Stack Length: " + top);
	}

	public synchronized int pop() {
		int ret = 0;
		while (-1 == top) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		ret = this.res[top];
		top--;
		// 唤醒其他进程
		this.notifyAll();
		System.out.println("------Stack Length: " + top);
		return ret;
	}
}

class Consummer implements Runnable {
	private final int numOfconsume = 20;
	private SynicStack synicStack = null;

	public Consummer(SynicStack ss) {
		this.synicStack = ss;
	}

	@Override
	public void run() {
		for (int i = 0; i < numOfconsume; i++) {
			int getRes = this.synicStack.pop();
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("consume Res： " + getRes);
		}
	}
}

class Producer implements Runnable {
	private final int numOfproduce = 40;
	private SynicStack synicStack = null;

	public Producer(SynicStack ss) {
		this.synicStack = ss;
	}

	public void run() {
		for (int i = 0; i < numOfproduce; i++) {
			synicStack.push(i);
			try{
				Thread.sleep(50);
			} catch (InterruptedException e){
				e.printStackTrace();
			}
			System.out.println(i + " was produced.");
		}
	}
}




  • 一个线程协作的例子

爸爸给女儿和儿子喂水果。爸爸随机挑选橘子或者苹果，将橘子剥皮或者将苹果削皮放在盘子中，剥皮的速度比较快，而削皮的时间比较慢。女儿只吃橘子，儿子只吃苹果（当然我们假设女儿和儿子永远也吃不饱）。盘子只能装下3个水果。儿子吃得比较快，女儿吃得比较慢。

编程模拟该过程：

（PS：这里http://blog.csdn.net/he_qiao_2010/article/details/8762387有linux C 对这个例子的进程实现）

简单分析

信号量：

int accessplate = 1;     //表示访问盘子的信号量

int apple = 0;             //苹果个数

int orange = 0;             //橘子

int emptyplates = 3;        //空盘子

这个例子的C代码进程实现，见“linux进程协作-一个小例子”。

这里用线程来模拟：

临界资源3个盘子，这里用一个字符串数组来表示：

String[]plates = new String[3];

每个进程对盘子进行访问的时候，对其加锁。

 

注：

1.如果用synchronized关键字修饰一个对象，则在程序执行的任意时刻，都只能由某一个线程去访问它，如果用synchronized关键字修饰一个方法，表示整个方法为同步方法。

2.Sleep和Wait都可以使线程等待一定的毫秒数，但是Sleep在等待过程中不释放对象锁，而wait在等待过程中释放对象锁。

代码：

package hq.org;
public class EateFruits {
	public static void main(String args[]) {
		Plates fruitPlates = new Plates();
		Father father = new Father(fruitPlates);
		Daughter daughter = new Daughter(fruitPlates);
		Son son = new Son(fruitPlates);

	Thread fThread = new Thread(father);
	Thread dThread = new Thread(daughter);
	Thread sThread = new Thread(son);

	fThread.start();
	dThread.start();
	sThread.start();
	
	//主线程每隔2秒打印出盘子的情况。
	while (true) {
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		fruitPlates.printPlates();
	}
	}
}

class Plates {
	private static int numOfApple;
	private static int numOfOrange;
	private static int numOfEmptyPlates;

	public Plates() {
		numOfApple = 0;
		numOfOrange = 0;
		numOfEmptyPlates = 3;
	}
	
	//打印出盘子中的情况
	public void printPlates() {
		System.out.println( "plates:" + numOfApple + " apples," + numOfOrange + " oranges,"
			+ numOfEmptyPlates + " empty plates.");
	}

	public synchronized void eatAnApple() {
		while (0 == numOfApple ) {
			//如果没有苹果，等待随机毫秒数，然后重新检测numOfApple值
			try {
				this.wait((long) (Math.random()*100));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		numOfApple--;
		numOfEmptyPlates++;
		//拿到苹果后，唤醒其他正沉睡的线程。
		this.notifyAll();
		//吃苹果的时间
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("Son Eat an Apple.");
	}

	public synchronized void eatAnOrange() {
		while (0 == numOfOrange ) {
			try {
				this.wait((long) (Math.random()*100));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		numOfOrange--;
		numOfEmptyPlates++;
		this.notifyAll();
		
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("Daughter Eat an orange.");
	}

	public synchronized void addAnApple() {
		while (3 == numOfApple || 0 == numOfEmptyPlates) {
			try {
				this.wait((long) (Math.random()*100));
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		numOfApple++;
		numOfEmptyPlates--;
		this.notifyAll();
		
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("Father Add an Apple.");
	}

	public synchronized void addAnOrange() {
		while (3 == numOfOrange || 0 == numOfEmptyPlates) {
			try {
				this.wait( (long) (Math.random()*100) );
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		numOfOrange++;
		numOfEmptyPlates--;
		this.notifyAll();
		
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("Father Add an orange.");
	}
}

class Daughter implements Runnable {
	private static Plates plates = null;

	public Daughter(Plates pl) {
		Daughter.plates = pl;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (plates) {
				plates.eatAnOrange();
			}
		}
	}

}

class Son implements Runnable {
	private static Plates plates = null;

	public Son(Plates pl) {
		Son.plates = pl;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (plates) {
				Son.plates.eatAnApple();
			}
		}
	}
}

class Father implements Runnable {
	private static Plates plates = null;

	public Father(Plates pl) {
		Father.plates = pl;
	}

	@Override
	public void run() {
		while (true) {
			synchronized (plates) {
				// is Apple(40%)
				if ((int) (Math.random() * 100) % 100 + 1 > 60) {
					try {
						Thread.sleep(250);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					Father.plates.addAnApple();
				}
				// is Orange(60%)
				else {
					try {
						Thread.sleep(250);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					Father.plates.addAnOrange();
				}
			}
		}
	}
}
运行结果：


he_qiao_2010
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初步学习Java中线程的实现与生命周期
09-03
主要介绍了初步学习Java中线程的实现与生命周期,线程方面的知识是Java学习过程中的重点和难点,需要的朋友可以参考下
【一】Java线程初步了解
热门推荐
Zack_tzh的博客
02-06 2万+
Java线程 一、进程与线程 进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，即进程空间或（虚空间）。进程不依赖于线程而独立存在，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，线程没有自己的虚拟地址空间，与进程内的其他线程一起共享分配给该进程的所有资源。 二、线程实现方式 （一）继承 Thread 类 public cla
Java 线程 基础知识总结
Zhangguohao666的博客
07-27 6204
文章目录线程基础生产消费者模型，synchronizedjoin方法+死锁（哲学家进餐问题）join和锁死锁有趣的Timer类Timer多线程的一个运行实例 初步认识下线程，线程怎么去实现（通过继承Thread或者实现Runnable接口） 线程基础 很不严谨的说，线程是什么？线程就是为了让很多个东东并发执行，大大的提高程序执行的效率啊 三个非常重要的概念： 程序：一组写好了的静态代码块（就我...
java多线程与并发原理学习笔记（一）——java线程初步认识
飞！！！的博客
02-17 348
java线程的创建以及启动和停止的方法
Java线程初步1
Andy_Su1990的专栏
10-18 606
1. Java创建线程,Runnable和Callable都是一个任务的概念，而不是线程，线程是Thread类，我们将一个Runnable和Callable的任务对象传递给Thread去执行，Thread再去调用该对象的run方法。 2. 为什么大家都推荐用任务对象来创建多线程，原因为一个runnable对象可以传递给多个Thread，可以达到数据共享，我当时看到就纳闷有static也是可以的嘛
java 多线程实验_JAVA线程实验
weixin_39820136的博客
02-20 500
实验11 线程一、实验目的1．线程的概念、线程的生命周期。2．多线程的编程：继承Thread类与使用Runnable接口。3．使用多线程机制实现动画。二、实验要求1．掌握利用JAVA语言编写多线程程序的方法2．掌握线程的调度方法3．掌握多线程环境中GUI程序的编写方法三、实验内容(一)Thread子类的方法实现多线程1．编写KY11_1.java 程序文件，源代码如下。class S...
java 线程耗尽_WebLogic执行线程耗尽解决方案
weixin_34360879的博客
03-07 936
WebLogic执行线程耗尽解决方案WebLogic执行线程耗尽1.1、概述 更多WebLogic相关知识·：WebLogic线程耗尽产生的原因有多种，一般而言线程耗尽是由于线程在争夺某种资源。当一种资源处于缺少状态，比如数据库JDBC连接池的达到最大连接数，就会导致后续的业务线程都卡在等待获取JDBC的连接上，最终导致服务器无法响应后续的服务请求。1.2、常见线程耗尽原因WebLogic服务器线...
JAVA学习线程的初步理解
struggel的博客
09-20 207
一丶线程的让步 yield()方法，执行后会进入就绪状态，等待线程的重新调度 二丶线程的插队 join()方法，在一个线程中调用此方法后插入另一线程，当线程执行完后继续执行之前的线程
Java线程里的14种锁
weixin_55415995的博客
10-26 863
一. 线程是否同步资源? 1. 悲观锁 :同步 每次拿数据都按照 最坏 的情况来定, 认为一定会有别的线程过来修改, 所以每次拿数据之前都会先上锁, 这样别的线程要想来拿这个数据的时候就会被阻塞, 直到这个线程解锁. 部分锁实现: synchronized的实现就是悲观锁, 主要用于多写的场景, 可以确保数据同步正确 存在的部分问题: 线程持有该锁会导致其他需要此锁的线程阻塞 竞争强烈的情况下, 不断的加锁和解锁都会影响cpu的调度从而出现性能问题 如果一个优先级高的线程等待一个优...
java线程初步学习
wangking:开源世界，人人都用上了正版啦。。。
09-11 578
这里写了一个小例子，学习一下线程实现的两种方式（继承自Thread类，实现Runnable接口），以及start(开启事务，调用run方法),yield（暂停当前正在执行的线程对象，并执行其他线程。）,join（等待该线程终止）,sleep（指定的毫秒数内让当前正在执行的线程休眠）,setPriority（设置优先级）。 package com.test;import java.uti
java线程理解小程序
07-05
一个安卓聊天和客户端的小程序 初步理解客户端与服务器的连接 还有线程的使用
java线程基础
03-01
java线程基础，线程初步接触者所需要了解的
java多线程开发初步入门
08-19
java程序员初学多线程的可以看看哦 csdn积分只要一分哦
java游戏线程界面
04-01
线程游戏界面，只是初步学习资料
Java实现基于百度地图的坐标拾取功能
he_qiao_2010的专栏
08-05 5502
功能用Java实现通过调用百度地图API，实现查找地点经纬度和范围的功能。注意百度地图地点搜索接口需要认证，且有访问限制：每天只能访问50万次。用法GeofencingDialog dialog = new GeofencingDialog(); dialog.setVisible(true); //显示对话框 String radius = dialog.getRadiusStr();
中国农历的Java实现
he_qiao_2010的专栏
09-07 5485
中国农历支持公历范围为：1900-01-31到2099-12-31范围内，农历日期和公历日期的转换。实现思路通过记录1900年-2099年间的农历信息到二维数组中，经过查询和相关计算就能实现公历日期和农历日期之间的转化。 例如： { 8, 131, 301, 331, 429, 528, 627, 726, 825, 924, 1023, 1122, 1222, 1320 }, // 1900
记一次重写RequestMappingHandlerMapping的经历
he_qiao_2010的专栏
06-20 4196
近期公司的产品做了一次安全审查，发现后端提供的接口有不安全的Http方法漏洞。不安全的HTTP方法一般包括：TRACE、PUT、DELETE、COPY 等。其中最常见的为TRACE方法可以回显服务器收到的请求，主要用于测试或诊断，恶意攻击者可以利用该方法进行跨站跟踪攻击（即XST攻击），从而进行网站钓鱼、盗取管理员cookie等。 原因分析 引起这个问题的原因其实很简单，因为开发人员开发接口的...
如何从jar包中读取配置文件
he_qiao_2010的专栏
08-05 3187
今天开发的时候遇到一个问题——当程序以jar包运行的时候,有个txt配置文件无法获取到,但是本地测试无法复现.后来发现是因为以Jar包形式运行，文件无法访问到，这里记录一下。 1. 如何判断当前进程是否以jar包形式运行的？ /** * 是否以Jar包运行 * * @return */ public static boolean isRunningInJar() ...
java中如何判断线程资源是否充裕
最新发布
09-19
在Java中，可以使用以下方法来判断线程资源是否充裕： 1. `Runtime.availableProcessors()`方法可以获取到当前系统可用的处理器核心数。通过比较当前系统可用的处理器核心数和需要使用的线程数量，可以初步判断线程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值