java并发线程---线程的使用

1.在学习之前我都会想这个问题，到底什么是线程？我们学习线程有什么用？

  线程：其实就是程序执行流的最小单元。但我觉得这样的书面描述不太好理解，我觉得通过举例的方式能更好的加深理解，首先要明白线程，我们要知道进程是什么？

所谓的进程就是我们程序的执行的过程，而程序有什么组成呢？答案就是有很多的线程组成，所以线程也叫轻量级的进程。比如我们的微信，我们既可以发送信息，也可以上传图

片，视频等，而这些小的模块我们就可以称之为线程。线程是组成程序不可少的部分，所以线程的知识很重要。

2.我们怎么去学习线程呢？

首先我们要知道的是在java中，我们要实现线程的方式要哪些？

第一种是通过继承的方式（继承Thread类） 然后第二种是实例化Runnable接口

3.线程有哪些方法？（这个完整的可以查看一下官方文档的API）

我就说说一些比较常用的Thread的方法：

（1）start()：线程的开启，启动。

（2）sleep()：线程的休眠。参数有时间等

（3）join()：运行当前的线程，使其他的进程需要等待，简单的来说就是插入一个线程，这个参数不同

（4）yield()：这个就是定义当前线程运行采取的方式，抢占资源，不一定运行哪一个。

（5）currentThread()：获取当前线程，返回本线程的引用。

有人会问，为什么没有看见结束进程的函数方法呢？

其实也是有的就是stop（）方法，但这个是decared，已经过期了的方法，（因为一旦执行完这个方法后，进程就会很突兀的完全停止，有一些方法不会执行，跟实际不符）。

有人可能又会说不是还有个 interrupt()方法吗？是的这个确实可以停止线程，但也会带来一些我们不需要的情况，因为他设置的初衷不是用来停止进程的，有的时候还会用到

Object方法里的wait（）等方法，

所以我在这里推荐用的是停止标识符号来终止进程。

下面我会通过代码来讲解上面用到的方法（注意看注释）

我打算通过美猴王大闹天宫的案例跟大家来聊一聊：

可能大家一开始不太理解，到底哪部分是哪部分的，你认真的屡一下

package myThread.test.thread;
/**
 * 实现线程的方式有两种，第一种是继承Thread类，第二种是实例化Runnable接口，
 * 在创建Thread的时候的方式是Thread t = new Thread(new 实例化接口的类，“线程的名”);
 */
public class mytestThread01 extends Thread {
	public void run(){
		System.out.println("线程:"+getName()+"我是美猴王，我从石头里蹦出来了");
		
		int count = 0;
		boolean flag = true;
		while(flag){
			System.out.println("线程:"+getName()+"我要做齐天大圣，你不给我要大闹天宫了"+(++count));
			if(count==100){
				flag = false;				
			}
			if(count%10==0){
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		System.out.println("线程:"+getName()+"没办法，我打不过佛祖，所以我要去西天取经了");
	}
public static void main(String[] args) {
	Thread monkey = new mytestThread01();
	monkey.start();
	Thread monkey01 = new Thread(new thread02(),"Thread-01");
	monkey01.start();
}
}
class thread02 implements Runnable{

	@Override
	public void run() {
System.out.println("线程:"+Thread.currentThread().getName()+"我是美猴王，我从石头里蹦出来了");
		
		int count = 0;
		boolean flag = true;
		while(flag){
			System.out.println("线程:"+Thread.currentThread().getName()+"我要做齐天大圣，你不给我要大闹天宫了"+(++count));
			if(count==100){
				flag = false;				
			}
			if(count%10==0){
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		System.out.println("线程:"+Thread.currentThread().getName()+"没办法，我打不过佛祖，所以我要去西天取经了");
		
	}
	
}

结果截图如下：

下面的是升级版本的大闹天宫

1.首先创建一个class实例化Runnable接口  Thread002.java:

package myThread.test.thread;

public class Thread002 implements Runnable {
	<span style="color:#ff0000;">//为了保证线程可以写入其他线程写入的词
	volatile boolean flag = true;</span>
	public void run(){
		//jvm 命名happens-before
		while(flag){
			int count;
			for(count=0;count<=5;count++){
				System.out.println(Thread.currentThread().getName()+"方，发起了["+count+"]次攻击");
				<span style="color:#ff0000;">//采用抢占cpu资源的方式，来让线程运行
				Thread.yield();</span>
			}			
			System.out.println(Thread.currentThread().getName()+"方，停止了攻击");
		}
	}

}

然后我们在实例化Runnable接口：Thread003：（这个是加入的线程）

package myThread.test.thread;

public class Thread003 implements Runnable{
	public void run(){
		System.out.println("双方打斗很猛，难以分出胜负");
		System.out.println(Thread.currentThread().getName()+"天帝无奈，于是半路请出了佛祖，佛祖加入战场");
		for(int i=0;i<=5;i++){
			System.out.println(Thread.currentThread().getName()+"佛珠开始战斗，第"+i+"次，发动进攻");
		}
		System.out.println(Thread.currentThread().getName()+"佛祖战斗结束了");
	}

}

然后我们在写一个继承Thread类的class:

package myThread.test.thread;

public class testThread002 extends Thread{
	public void run(){
		System.out.println("大闹天宫开始了");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		//创建接口实例化的对象
		Thread002 threadMonkey = new Thread002();
		Thread002 threadKing = new Thread002();
		//创建线程实例化对象
		Thread thread01 = new Thread(threadMonkey,"美猴王");
		
		Thread thread02 = new Thread(threadKing,"天帝");
		//大闹天宫开始
		thread01.start();
		thread02.start();
		//双方的战斗需要休整，所以我们给点时间他们休息
		try {
			//线程的休眠
			Thread.sleep(500);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Thread003 ThreadFo = new Thread003();
		Thread ThreadFo1 = new Thread(ThreadFo,"关键方");
		System.out.println("佛祖准备出场");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		threadMonkey.flag = false;
		threadKing.flag = false;
		//双方停战，天帝方去寻找佛祖
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
		ThreadFo1.start();
		try {
			ThreadFo1.join();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("所以战斗结束了，天帝方胜利了");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("大闹天宫结束了，下次讲解西天取经");;
	}
public static void main(String[] args) {
	new testThread002().start();
}
}

结果截图如下：

后面我会逐一介绍线程的一些知识，谢谢大家的支持！