先举个例子
计算机的核心是CPU，它承担了计算机所有计算任务，可以把它理解为像一个工厂，时刻在运行。
假定工厂有一个电力系统，工厂有很多车间，一次只能供给一个车间使用，也就是说一个车间开工的时候，其他车间必须停工。背后的含义就是单个CPU一次只能运行一个任务，所以现在的计算机都是多核的。
进程就好比工厂的车间，它代表CPU所能处理的单个任务。任何一个时刻，CPU总是运行一个进程，其他进程处于非运行状态（这是针对单核来说的）
在 一个车间里，可以有很对工人，他们协同完成一个任务，线程就好比车间里的工人，一个（车间）进程可以包含多个（工人）线程。
从而得出：
进程：系统进行程序的基本单位，有独立的内存空间和系统资源（简单的可以理解为一个软件的运行，如一个qq的运行就是一个进程）
线程：进程中执行运算的最小单位，处理机分配给线程，即真正在处理机上运行的是线程。
线程的实现
两种方式：
-->继承Thread类 （extends），重写run()方法，调用start()启动线程
-->实现runnable接口（implements），重写run()方法，调用start()启动线程
线程的命名
一般在线程启动前去命名，不建议启动后在修改，也不建议对不同的线程取相同的名字
两种命名方式：系统默认命名和自定义名称
class MyThread extends Thread{
public void run(){
for (int i = 0; i <=5; i++) {
//获得当前线程的名字
//得到的结果为如：Thread-0、Thread-1 默认的线程名称从0开始
System.out.println(Thread.currentThread().getName()+"-"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test07 {
public static void main(String args[]) {
MyThread t=new MyThread();
//自定义名称的操作：传参 命名
new Thread(t,"我").start();
new Thread(t,"你").start();
//未命名，从0开始编号
new Thread(t).start();
}
}
线程的休眠
就是让线程执行慢下来
Thread.sleep(时间);
线程的优先级
class MyDThread extends Thread{
public void run(){
for (int i = 0; i <=5; i++) {
//获得当前线程的名字
System.out.println(Thread.currentThread().getName()+"-"+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public class Test08 {
public static void main(String args[]) {
MyDThread t=new MyDThread();
Thread t1=new Thread(t,"我");
Thread t2=new Thread(t,"你");
Thread t3=new Thread(t,"他");
/*
* 设置线程的优先级，1最低 10最高
* 优先级不是那么绝对的优先，只是有几率的优先
* 其实就是人民币玩家和普通玩家的区别
* 人民币玩家 <高优先 但不是无敌的> 普通玩家<也是有几率胜的>
*/
t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}
本章常见问题
1.一个JVM进程启动时至少启动几个线程？
2个：main主线程 gc线程：垃圾回收
2.主线程main方法的优先级别是数字多少？
中等级别5
线程的同步
同步：就是一个线程对象，要等待另一个线程对象执行完成之后的操作规则
两个方法：
同步代码块
同步方法
同步异步的优缺点
异步效率高
同步线程安全
public class Test09 {
public static void main(String[] args) {
MyThread1 myThread=new MyThread1();
new Thread(myThread,"售货员A").start();
new Thread(myThread,"售货员B").start();
new Thread(myThread,"售货员C").start();
new Thread(myThread,"售货员D").start();
}
}
class MyThread1 implements Runnable{
int count=5;
@Override
//synchronized public void run() { 同步方法，在方法前面加上synchronized
public void run() {
for (int i = 1; i <10; i++) {
synchronized (this) {
if(count>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖了第"+(count--)+"个包子");
}
} }
}
}
死锁：当线程同步过多时，就会产生死锁
就好比我在*等你，你在王府井等我，我们都在等待，但永远等不到对方，最后就只能等死了.....