线程

多线程：
进程：
程序是静止的，只有真正运行时的程序才被称为进程（任务管理器查看），单核CPU在任何时间点上，只能运行一个进程；宏观
并行、微观串行。
DOS命令：wmic下cpu get NumberOfCores 获得真实CPU核数
线程;Thread：
称其为轻量级进程，程序中的一个顺序控制流程，同时也是CPU的基本调度单位。
进程由单个或多个线程组成，彼此间完成不同的工作，交替执行，称为多线程。
线程的组成：
任何一个线程都具有基本的组成部分：
CPU时间片：操作系统（OS）会为每个线程分配执行时间。
运行数据：
堆空间：储存线程需要使用的对象，多个线程可以共享堆中的对象。
栈空间：储存线程需使用的局部变量，每个线程都有独立的栈。
逻辑代码。
线程的创建：
1、继承Thread，重写run方法即线程的任务，创建对象调用start启动线程并由JVM默认调用run
2、实现Runnable，重写run方法，创建实现类对象，创建Thread线程对象传参，调用start方法。
因为以实现接口的方式创建线程实际上是创建当前类编程线程任务类，本身不是线程，任务是可以多个线程对象共享；
也可以继承线程后实现线程表示增加行为能力更灵活，不影响继承。
Thread.currentThread().getName(); //获取线程名字
线程的基本状态：
初始状态：
线程对象创建，只是在堆开辟内存，与常规对象无异。
就绪状态:：
调用start，等待OS选中，并分配时间片。
运行状态：
获得时间片之后，进入运行状态，如果时间片到期，则回到就绪状态
终止状态：
主线程main或独立线程run结束，并释放持有的时间片
有限期等待：
sleep期限内等待。结束后返回就绪状态。
无限期等待：
join插队执行完毕后返回就绪状态。
阻塞状态：
多个线程访问带锁共享实例时，未获得锁线程进入等待状态直至带锁线程原子操作完毕
JDK5之后，就绪状态与运行状态统称Runnable
休眠：
Thread.sleep（long millis）
表示当前线程主动休眠millis毫秒
可设定特定条件下休眠即暂停执行。
放弃：
yield（）：
主动放弃当前持有的时间片，回到就绪状态，竞争下一下时间片。
结合：
join（）：
将另一个线程加入到执行线程中中，等插入线程执行结束后，main再加入竞争
在此期间不影响其他线程参与竞争时间片。
线程安全：
线程不安全：
当多线程并发访问临界资源时，如果破坏原子操作，可能造成数据不一致。
临界资源：
共享资源（内存中同一对象），一次仅允许一个线程使用，才可保证其正确性。
原子操作：
不可分割的多部操作，被视为一个整体，其顺序和步骤不可打乱或缺省。
保证线程安全：
同步代码块：
synchronized(临界资源对象)｛//对临界资源对象加锁，不会再被分割，即使休眠也不会释放
//锁，直至原子代码块执行完毕。
//原子操作
｝ （必须保证临界资源对象有锁且每个对象仅有一个锁）

作业：
1、
一个单CPU的机器，如何同时执行多个线程？请简述其原理。
CPU会为每个线程分配执行CPU时间片，多个线程彼此间完成不同的工作，交替执行。
2、

public class Example implements Runnable {
	public void run() {
		while (true) {

		}
	}

	public static void main(StringBuilder[] args) {
		Example ex1 = new Example();
		Example ex2 = new Example();
		Example ex3 = new Example();
		ex1.run();
		ex2.run();
		ex3.run();
	}
}
//三个					

3、

class Example implements Runnable {
	public static void main(String[] args) {
		Thread t = new Thread(new Example());
		t.start();
	}

	public void run(int limit) {
		for (int x = 0; x < limit; x++) {
			System.out.println(x);
		}
	}
	// 没有明确输出，因为调用实现无参run方法
	// 增加如下：

	public void run() {
		// TODO Auto-generated method stub

	}
}

4、

class Example {
	public static void main(String[] args) {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("sleep");
	}
}

5、

class MyThread1 extends Thread {
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("1~26");
		}

	}
}

class MyThread2 implements Runnable {
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.err.println("A~Z");
		}
	}
}

6、

public class TestMyThread {

	public static void main(String[] args) {
		Object lock = new Object();
		Thread t1 = new MyThread1(lock);
		Thread t2 = new MyThread2(lock);
		t1.start();
		t2.start();
	}
}

class MyThread1 extends Thread {
	Object lock;

	public MyThread1(Object lock) {
		this.lock = lock;
	}

	public void run() {
		synchronized (lock) {// 2
			for (int i = 0; i <= 10; i++) {
				try {
					Thread.sleep((int) (Math.random() * 1000));
				} catch (Exception e) {
					System.out.println("$$$");
				}
			}
		}
	}
}

class MyThread2 extends Thread {
	Object lock;

	public MyThread2(Object lock) {
		this.lock = lock;
	}

	public void run() {
		synchronized (lock) {// 1
			for (int i = 0; i <= 10; i++) {
				try {
					Thread.sleep((int) Math.random() * 1000);
				} catch (Exception e) {
					System.out.println("###");
				}
			}
		}
	}
}

//在//1和//2处加上的synchronized起什么作用？如果不加synchronized，运行程序有什么不同的地方？
//保证线程的安全，如不加锁，当多线程访问临界资源时破坏原子操作，导致数据不完全

7、

public class TestMyThread {

	public static void main(String[] args) {
		Thread t1 = new MyThread("Hello");
		Thread t2 = new MyThread("World");
		t1.start();
		t2.start();

	}

}

class MyThread extends Thread {
	private String data;

	public MyThread() {
	};

	public MyThread(String data) {
		this.data = data;
	}

	public void run() {
		synchronized (data) {
			for (int i = 0; i < 10; i++) {
				try {
					Thread.sleep((int) (Math.random() * 1000));
				} catch (Exception e) {
					System.out.println(data);
				}
			}
		}
	}
}