java中多线程

 Content:
1.线程的基本概念

2.线程的实现方式

3.后台线程

4.线程的状态与基本控制方法

5.线程的让步、睡眠与合并

6.线程的优先级

7.synchronized关键字

 

Analysize:
一、.线程的基本概念
 我们可以把程序里面的每一行代码看成一个点
逐行代码执行就构成了一条线，称之为“线程”，每一个线程都是顺序执行的
1.进程
一个进程就是一个正在运行的程序的实例，每个进程都有它自己的内存空间
一个进程有一个或多个线程组成

2.多进程 – 在操作系统中同时运行的多个程序
 多线程 – 同一个进程中同时运行的多个顺序流

3.为什么要多线程？
单线程的程序在执行时，某一个时刻只能有某一段代码能够被执行，设想你正在编写一个FTP上传工具，当这个工具正在上传数据的时候，你希望有一个按钮能够响应用户的取消动作，对单线程的程序，要完成这样的功能将非常困难（你可能要轮询这个按钮，看是否有点击事件），而如果是多线程程序，完成起来将很轻松

二、线程的创建方式

第一种方式
创建一个类（比如MyThread），让它继承Thread类，重写run方法
创建这个类(MyThread)的一个对象，调用其start()方法以启动线程
第二种方式
创建一个类(比如MyThread)，实现Runnable接口，实现run方法
创建一个Thread类的一个对象，并以MyThread类的对象作为其构造方法参数
调用Thread对象的start()方法以启动线程
三、后台线程

在后台提供一种通用服务的线程。当所有非后台线程结束之后，程序就终止了。换句话说，即使daemon Thread还在运行，当其它非daemon线程都已经结束之后，程序就已结束！

实现：

 

四、线程的基本控制方法

 

五、线程的让步、睡眠与合并

     1.线程的让步：调用yield()方法

实现代码：

 

public class MyThread implements Runnable {
	public void run() {
		for(int i=0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}
public class MyThreadClient {
	public static void main(String[] args){
		Thread t = new Thread(new MyThread());
		t.start();
		for(int i=0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
			Thread.yield();
		}
	}
}

 

    2.线程的睡眠：调用sleep()方法

    实现代码：

public class MyThread implements Runnable {
	public void run() {
		for(int i=0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
			try {
				//这个睡眠时间不是绝对精确的时间
				Thread.sleep(1000);
			} catch (InterruptedException e) {
  				throw new RuntimeException(e);
			}
		}
	}
}
public class MyThreadClient {
	public static void main(String[] args){
		Thread t = new Thread(new MyThread());
		t.start();
		for(int i=0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		}
	}
}

 

 

3.线程的合并：

       假设在线程b上调用线程a.join()方法，b线程将被挂起（暂停执行），直到a线程执行完成之后，b线程才会继续往下执行，这称为线程的合并

实现代码：

public class BThread extends Thread {
	private Thread a; //为了能够加入a线程，在b中持有对a的引用
	public BThread(String name,Thread a){
		super(name);
		this.a = a;
	}
	@Override
	public void run() {
		for(int i=0; i<10; i++){
			System.out.println(getName()+i);
			try {
				sleep(1000);
				if(i == 3){
					a.join();
				}
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		}
		System.out.println(getName()+"执行结束！");
	}
}

 

六、线程的优先级

1.优先级相当于是“重要性”的意思，意味着优先，执行频率较高，但不意味着低优先级的线程得不到执行！
2.setPriority()方法可以在任何时候调用（即不一定非得在start()方法之前调用），以改变其优先级
3.优先级的取值由1到10，不能超过这个范围（否则报错）

实现代码：

public class MyThread implements Runnable {
	public void run() {
		for(int i=0; i<10; i++){
			System.out.println(Thread.currentThread().getName()+":"+i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				throw new RuntimeException(e);
			}
		}
	}
}
public class MyThreadClient {
	public static void main(String[] args){
		Thread t0 = new Thread(new MyThread());
		t0.setPriority(Thread.MIN_PRIORITY);//最小
		t0.start();
		Thread t1 = new Thread(new MyThread());
		t1.setPriority(Thread.NORM_PRIORITY);//标准
		t1.start();
		Thread t2 = new Thread(new MyThread());
		t2.setPriority(3);//3
		t2.start();
		Thread t3 = new Thread(new MyThread());
		t3.start();
		t3.setPriority(Thread.MAX_PRIORITY);//最高
	}
}

 

七、synchronized关键字

1.synchronized关键字被添加到实例方法的前面时，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法(对象级的锁)

2.synchronized可放在实例方法与静态方法前面

3.synchronized可定义一个同步代码块

实现代码：

 synchronzied (this){

       if(blanace>=i){
            try{
                       Thread.sleep(1000);
                }catch(InterruptedException e){
                       e.printStack();
                 }
           }

}