线程入门简介
什么是程序?
是为完成特定任务，用某种语言编写的一组指令集合。`
简单的说：就是我们写的代码
什么是进程?
进程是指运行中的程序，操作系统会为进程分配内存空间
进程是你程序的一次执行过程，或是正在运行的一个程序，是动态 过程，它自身的产生、存在和消亡过程
启动一个程序
启动两个程序
结束进程之后，进程就随之消亡
什么是线程？
1.线程是由进程创建的，是进程的实体
2.一个进程可以拥有多个线程
当你在使用百度网盘下载东西的时候，你可以将百度网盘的整体界面看成一个进程，当它每次下载一个东西的时候对应启动一个线程
单线程与多线程
单线程：同一时刻，只允许执行一个线程
多线程：同一时刻，可以执行多个线程，比如百度网盘下载东西
并发与并行
并发：同一时刻，多个任务交替执行，造成一种你好像看起来它们同时的错觉，简单的说，单核cpu实现的多任务就是并发
并行：同一时刻，多个任务同时执行,多核cpu可以实现并行
你可以将cpu想象成我们的大脑，一个人只有一个，你能遍看电视遍写作业吗，在你心里可能感觉你可以有这个能力，但其实你这是在看电视和做作业的过程中来回不断切换
并发和并行可能同时存在
线程的使用
用java查看有多少个cpu
示例代码：
public class CpuNum {
public static void main(String[] args) {
Runtime runtime = Runtime.getRuntime();
//获取当前电脑的cpu数量
int cpuNums = runtime.availableProcessors();
System.out.println("当前有cpu个数 = "+cpuNums);
}
}
运行结果:
创建线程的两种方式
继承Thread类，重写run方法
示例：每隔1s输出一句小猫喵喵叫
public class Thread01 {
public static void main(String[] args) {
//创建Cat对象，可以当线程使用
Cat cat = new Cat();
cat.start();//启动线程
}
}
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类 实现了Runnable接口的run方法
/* @Override
public void run() {
if (target != null) {
target.run();
}
}*/
class Cat extends Thread{
int times = 0;
@Override
public void run() {
//重写run方法，写上自己的业务逻辑
while(true) {
//该线程每隔1秒，在控制台输出”喵喵，我是小猫咪“
System.out.println("喵喵，我是小猫咪"+(++times));
//让该线程休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
示例：在上述的基础之后，加上一个仅仅输出8次的条件
public class Thread01 {
public static void main(String[] args) {
//创建Cat对象，可以当线程使用
Cat cat = new Cat();
cat.start();//启动线程
}
}
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类 实现了Runnable接口的run方法
/* @Override
public void run() {
if (target != null) {
target.run();
}
}*/
class Cat extends Thread{
int times = 0;
@Override
public void run() {
//重写run方法，写上自己的业务逻辑
while(true) {
//该线程每隔1秒，在控制台输出”喵喵，我是小猫咪“
System.out.println("喵喵，我是小猫咪"+(++times));
//让该线程休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times==8){
break;//当times 到80，退出while，这时线程就会结束
}
}
}
}
实现Runnable接口，重写run方法
实现案例：请编写程序，该程序可以每隔1秒，在控制台输出"hi"，当输出10次后，自动退出
public class Thread02 {
public static void main(String[] args) {
Dog dog = new Dog();
//dog.start();这里不能调用start
//创建Thread对象,把dog对象(实现Runnable)，放入Thread
Thread thread = new Thread(dog);
thread.start();
}
}
class Dog implements Runnable{
//通过实现Runnable接口，并发线程
int count = 0;
@Override
public void run() {
//普通方法
while(true){
System.out.println("小狗汪汪叫..hi"+(++count)+Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(count==10){
break;
}
}
}
}
这里底层使用了设计模式（代理模式）
模拟代理类
//线程代理
class ThreadProxy implements Runnable{
//把Proxy当成ThreadProxy
private Runnable target = null;//属性，类型是Runnable
@Override
public void run() {
if(target!=null){
target.run();
}
}
public ThreadProxy(Runnable target){
this.target = target;
}
public void start(){
start0();//这个方法时真正实现多线程方法
}
public void start0(){
run();
}
}
多线程机制
多个线程同时进行
示例代码：
public class Thread01 {
public static void main(String[] args) throws InterruptedException {
//创建Cat对象，可以当线程使用
Cat cat = new Cat();
cat.start();//启动线程
//说明：当main线程启动了一个子线程 Thread-0，主线程不会阻塞,会继续执行
//这时，主线程和子线程是交替执行
System.out.println("主线程继续执行"+Thread.currentThread().getName());//名字main
for (int i=0;i<10;i++){
System.out.println("主线程 i="+i);
//让主线程休眠
Thread.sleep(1000);
}
}
}
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2.我们会重写run方法，写上自己的业务代码
//3.run Thread 类 实现了Runnable接口的run方法
/* @Override
public void run() {
if (target != null) {
target.run();
}
}*/
class Cat extends Thread{
int times = 0;
@Override
public void run() {
//重写run方法，写上自己的业务逻辑
while(true) {
//该线程每隔1秒，在控制台输出”喵喵，我是小猫咪“
System.out.println("喵喵，我是小猫咪"+(++times)+"线程名 = "+Thread.currentThread().getName());
//让该线程休眠1秒
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(times==80){
break;//当times 到80，退出while，这时线程就会结束
}
}
}
}
执行流程，当我们去运行的时候，打开一个进程，由这个进程给我们启动了一个主线程，主线程里面有开启了一个子线程，等所有线程均挂掉的时候，进程才随之结束，只要有一个线程存活，应用程序就还没有结束
为社么是start?
run方法就是一个普通的方法，没有真正的启动一个线程，就会把run方法执行完毕才向下执行，即会阻塞
源码解析
（1）
public synchronized void start(){
start0();
}
(2)
//start0()是本地方法，是jvm调用，底层是c/c++
//真正实现多线程的效果，是start0（），而不是run
private native void start0();
start()方法调用start0()方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于CPU，由CPU统一调度。