Java多线程并发编程

Java线程：概念与原理

一、操作系统中线程和进程的概念

现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

线程是指进程中的一个执行流程，一个进程中可以运行多个线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。

二、Java中的线程

在Java中，“线程”指两件不同的事情：

1、java.lang.Thread类的一个实例；

2、线程的执行。

使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。

一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。

Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。

一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。

一旦创建一个新的线程，就产生一个新的调用栈。

线程总体分两类：用户线程和守候线程。

当所有用户线程执行完毕的时候，JVM自动关闭。但是守候线程却不独立于JVM，守候线程一般是由操作系统或者用户自己创建的。

Java 多线程实现

1.继承 Thread 类

public class Thread1 extends Thread{
	private int baoZi=1;
	private String threadName;
	public Thread1(String threadName) {
		this.threadName = threadName;
	}
	public void run() {
		while(baoZi<=10){
			try {
				//因为实例很简单，计算机处理速度太快了就看到实际效果
				Thread.sleep(100);//这里就设置延迟0.1秒
				System.out.println(threadName+" 吃第"+baoZi+"包子");
				baoZi++;
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		System.out.println("张三，李四一起吃包子，每人吃了10个");
	//我们有十个包子，如果使用原先那种编程方式写一个循环处理（吃包子）用了假如10秒钟，这种方式是一个人在吃包子（一个线程处理）
		//现在我们使用多线程，用两个线程处理也就修是两个人吃包子（多线程处理）只用了1秒钟

<span style="white-space:pre">		</span>//在说的通俗点老的编程方式是一个人吃包子

<span style="white-space:pre">		</span>//现在使用多线程就是多个人同时在吃包子，你就懂了中间的效率问题了
		//这就是一个效率的问题
		//同时对多项任务加以控制或者是对一个任务加以多项处理
		Thread1 t1=new Thread1("张三线程");
		Thread1 t2=new Thread1("李四线程");
		t1.start();
		t2.start();
	}
}

  

 2.实现 Runnable 接口

public class Thread2 implements Runnable{
	private int baoZi=1;
	private String threadName;

	public Thread2(String threadName) {
		this.threadName = threadName;
	}
	//synchronized表示线程同步
	public synchronized void run() {
		while(baoZi<=10){
			try {
				//因为实例很简单，计算机处理速度太快了就看到实际效果
				Thread.sleep(100);//这里就设置延迟0.1秒
				System.out.println(threadName+" 吃第"+baoZi+"包子");
				baoZi++;
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}//这里就设置延迟0.1秒
		}
	}
	public static void main(String[] args) {
		//继承 Thread 类和实现 Runnable 接口两种方式多差不多
		//同样是刚才那个吃包子的实例
		//这里意思是开启三个线程处理
		Thread2 t1=new Thread2("超级张三线程");
		Thread t11=new Thread(t1);
		Thread t12=new Thread(t1);
		Thread t13=new Thread(t1);
		// 实现资源共享
		t11.start();
		t12.start();
		t13.start();
	}
}

如果 上述实例你还不明白

我在举例：听音乐、吃饭。在原先编程处理的话，你只能听完音乐在吃饭，或者是吃完饭在听音乐，不能两件事情同时执行，那就要使用多线程并发执行处理。

<span style="font-size:18px;">/**
 * 听音乐的事件
 * @author 李福平
 *
 */
public class Music extends Thread{

	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			try {
				//因为实例很简单，计算机处理速度太快了就看到实际效果
				Thread.sleep(100);//这里就设置延迟0.1秒
				System.out.println("听音乐");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}</span>

<span style="font-size:18px;">/**
 * 吃饭的事件
 * @author 李福平
 *
 */
public class Eat extends Thread{

	@Override
	public void run() {
		for(int i=0;i<1000;i++){
			try {
				//因为实例很简单，计算机处理速度太快了就看到实际效果
				Thread.sleep(100);//这里就设置延迟0.1秒
				System.out.println("吃饭");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}</span>

<span style="font-size:18px;">public class Demo1 {
	//测试类
	public static void main(String[] args) {
		/**
		 * 利用多线程实现一边吃饭一边听歌
		 */
		Music musicThread=new Music();
		Eat eatThread=new Eat();
		musicThread.start();
		eatThread.start();
	}
}</span>