java线程学习（一）

线程的基本概念：

     线程是一个程序的内部控制流。

线程和进程的区别：

1. 每个进程都有独立的代码和数据空间，进程间的切换会有较大的开销
2. 线程可以看成轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器（PC），线程切换的开销小。
3. 多进程：在操作系统中的能够同事运行多个任务（程序）
4. 多线程：在同一应用程序中有多个顺序流同事执行

线程的运行机制：

java的线程是通过java.lang.Thread的类实现的。VM启动时会有一个由主方法（public  static void main(){} ）所定义的线程，可以通过Thread的实列来创建新的线程，每个线程都是通过特定Thread对象所对应的方法run() 来完成操作的，方法run() 称为线程体。通过调用Thread类的start()方法来启动一个线程。

线程的实列：

　   进程只是一个静态的概念，机器上的一个.class文件，机器上的一个.exe文件，这个叫做一个进程。程序的执行过程都是这样的：首先把程序的代码放到内存的代码区里面，代码放到代码区后并没有马上开始执行，但这时候说明了一个进程准备开始，进程已经产生了，但还没有开始执行，这就是进程，所以进程其实是一个静态的概念，它本身就不能动。平常所说的进程的执行指的是进程里面主线程开始执行了，也就是main()方法开始执行了。进程是一个静态的概念，在我们机器里面实际上运行的都是线程。

　　Windows操作系统是支持多线程的，它可以同时执行很多个线程，也支持多进程，因此Windows操作系统是支持多线程多进程的操作系统。Linux和Uinux也是支持多线程和多进程的操作系统。DOS就不是支持多线程和多进程了，它只支持单进程，在同一个时间点只能有一个进程在执行，这就叫单线程。

　　CPU难道真的很神通广大，能够同时执行那么多程序吗？不是的，CPU的执行是这样的：CPU的速度很快，一秒钟可以算好几亿次，因此CPU把自己的时间分成一个个小时间片，我这个时间片执行你一会，下一个时间片执行他一会，再下一个时间片又执行其他人一会，虽然有几十个线程，但一样可以在很短的时间内把他们通通都执行一遍，但对我们人来说，CPU的执行速度太快了，因此看起来就像是在同时执行一样，但实际上在一个时间点上，CPU只有一个线程在运行。

创建线程的方法和启动：

 

在java里的线程创建主要是俩种方法：第一种是通过实现Runnable接口来实现的，一种是继承Thread来时间的，而（public static  void main（））是主线程，可用通过创建Thread的实列来创建新的线程。

eg：（一）使用Runnable接口创建和启动新的线程，在调用新线程的run()方法。

package javastudy.Runnable;


public class TestThread{
	public static void main(String[] args) {
		Run1 run1 = new Run1();//创建一个新的线程对象
		//run1.run();//调用线程的方法，执行之后才会往下执行
		Thread thread = new Thread(run1);//启用新的线程就的创建Thread对象
		thread.start();//启动线程
		
		for (int i = 0; i < 10; i++) {
			System.out.println("main:"+i);
		}
		
		
	}
}


class Run1 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("runnable:"+i);
		}
	}
}
	public static void main(String[] args) {
		Run1 run1 = new Run1();//创建一个新的线程对象
		//run1.run();//调用线程的方法，执行之后才会往下执行
		Thread thread = new Thread(run1);//启用新的线程就的创建Thread对象
		thread.start();//启动线程
		
		for (int i = 0; i < 10; i++) {
			System.out.println("main:"+i);
		}
		
		
	}
}


class Run1 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("runnable:"+i);
		}
	}
}

运行结果：

main:0
main:1
runnable:0
runnable:1
main:2
main:3
main:4
main:5
main:6
main:7
main:8
main:9
runnable:2
runnable:3
runnable:4
runnable:5
runnable:6
runnable:7
runnable:8

（二）：继承Thread类，并重写其run()方法：

package javastudy.Runnable;

public class TestThread{
	public static void main(String[] args) {
		//创建线程实列，直接调用是其start()的方法
		Run1 run1 = new Run1();
		run1.start();
		
		for (int i = 0; i < 10; i++) {
			System.out.println("main:"+i);
		}
		
		
	}
}

/**
 * 继承Thead类，重写其run的方法
 */
class Run1 extends Thread{
	//重写Thread的run方法
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("runnable:"+i);
		}
	}
}

总结：创建线程的俩种方法，优先选择实现Runnable接口，接口能实现多个，而继承制是单继承。

Runnable 和 Thread 的区别：

• 适合多个相同的代码程序线程去调用同一资源
• 可以避免Thread单继承的局限性
• 实现多个线程资源共享，代码和数据相分开
• 线程池只能放入实现Runnable或者是callable类线程

学习线程首先要理清楚三个概念：

1. 进程：进程是一个静态的概念
2. 线程：一个进程里面有一个主线程叫main()方法，是一个程序里面的，一个进程里面不同的执行路径。
3. 在同一个时间点上，一个CPU只能支持一个线程在执行。因为CPU运行的速度很快，因此我们看起来的感觉就像是多线程一样。

什么才是真正的多线程？如果你的机器是双CPU，或者是双核，这确确实实是多线程。

 

线程状态的转换：

（1）线程的装换图

（2）线程控制的基本方法

（3）sleep/join/yield的方法

这里的合并有点不好理解，那为什么要调用join的方法呢?

在主线程开始之后运行子线程，假如子线程的方法中有大量的算法，这样子线程就会耗时时间产长，往往主线程子会在的主线程没有结束的情况下结束，如果主线程在结束之后处理别的线程要用到子线程的运行的返回结果，这时我们调用子线程的join() 的方法，意思就是等子线程运行结束之后，主线程在结束。

例子（没有使用线程的join()方法）：

package Thread.study.join;

/**
 * @ClassName ThreadJoin
 * @Description 
 * @Author guojia
 * @Date 2019年4月22日 下午2:08:44
 */
public class ThreadJoin extends Thread {
	
	private String name;

	public ThreadJoin(String name) {
		super();
		this.name = name;
	}

	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+"子线程运行开始");
		for (int i = 0; i < 5; i++) {
			System.out.println("子线程"+name+"运行:"+i);
			try {
				Thread.sleep((int)Math.random()*10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+"子线程运行结束");
	}
}

测试：

package Thread.study.join;

/**
 * 
 * @ClassName ThreadTest
 * @Description 
 * @Author guojia
 * @Date 2019年4月22日 下午2:02:20
 */
public class ThreadTest {

	public static void main(String[] args) {
		System.out.println("主线程开始运行");
		ThreadJoin threadA = new ThreadJoin("A");
		ThreadJoin threadB = new ThreadJoin("B");
		threadA.start();
		threadB.start();
		System.out.println("主线程运行结束");
		
	}
}

结果：

主线程开始运行
主线程运行结束
Thread-0子线程运行开始
子线程A运行:0
Thread-1子线程运行开始
子线程B运行:0
子线程A运行:1
子线程B运行:1
子线程A运行:2
子线程B运行:2
子线程A运行:3
子线程B运行:3
子线程A运行:4
子线程B运行:4
Thread-0子线程运行结束
Thread-1子线程运行结束

使用join方法：

package Thread.study.join;

/**
 * 
 * @ClassName ThreadTest
 * @Description 
 * @Author guojia
 * @Date 2019年4月22日 下午2:02:20
 */
public class ThreadTest {

	public static void main(String[] args) throws Throwable {
		System.out.println("主线程开始运行");
		ThreadJoin threadA = new ThreadJoin("A");
		ThreadJoin threadB = new ThreadJoin("B");
		threadA.start();
		threadB.start();
		threadA.join();
		threadB.join();
		System.out.println("主线程运行结束");
		
	}
}

结果：

主线程开始运行
Thread-1子线程运行开始
子线程B运行:0
Thread-0子线程运行开始
子线程A运行:0
子线程A运行:1
子线程B运行:1
子线程A运行:2
子线程B运行:2
子线程A运行:3
子线程A运行:4
子线程B运行:3
Thread-0子线程运行结束
子线程B运行:4
Thread-1子线程运行结束
主线程运行结束

这就是线程的join()方法的作用。

yield：它的作用是暂停当前运行的线程，让其他线程的运行的。

yield和sleep的区别？

字面的意思它俩的作用是差不多的，但是实际运行机制是不一样的。sleep是让当前线程的处于停滞状态，在程序设置的时间内肯定是不会执行的，而yield则是让线程处于可执行状态，当该线程处于可执行状态的时候，会判断是否有同等优先级的线程处于可运行的状态，如果有就让其执行，反之该线程会立即执行。sleep的方法会让有优先级较低的线程获取运行资源运行，而yield不可能让出的优先级较低的线程CPU占有权。