run方法用于定义线程任务
interrupt方法用于中断线程
yield用于让出CPU时间
start方法用于启动线程
常见线程有两种方式:
定义一个线程类，重写run方法，在其中定义线程要执行的任务(希望和其他线程并发执行的任务)。
优点:
在于结构简单，便于匿名内部类形式创建。
缺点:
- 1:由于java是单继承的，直接继承线程，会导致不能在继承其他类去复用方法，这在实际开发中是非常不便的。
- 2:定义线程的同时重写了run方法，会导致线程与线程任务绑定在了一起，这等于将线程的任务定义在了这个线程中导致线程只能干这件事。不利于线程的重用。
注:启动该线程要调用该线程的start方法，而不是run方法！！！
package thread;
//创建方式一：定义线程类，并继承Thread（缺点1）
public class ThreadDemo1 {
public static void main(String[] args) {
//创建两个线程
Thread t1 = new MyThread1();
Thread t2 = new MyThread2();
/*
启动线程,注意:不要调用run方法！！
线程调用完start方法后会纳入到系统的线程调度器程序中被统一管理。
线程调度器会分配时间片段给线程，使得CPU执行该线程这段时间，用完后
线程调度器会再分配一个时间片段给一个线程，如此反复，使得多个线程
都有机会执行一会，做到走走停停，并发运行。
线程第一次被分配到时间后会执行它的run方法开始工作。
*/
t1.start();
t2.start();
}
}
//第一个线程类
class MyThread1 extends Thread{
public void run(){
for (int i=0;i<1000;i++){
System.out.println("hello姐~");
}
}
}
//第二个线程类
class MyThread2 extends Thread{
public void run(){
for (int i=0;i<1000;i++){
System.out.println("来了~老弟!");
}
}
}
package thread; //第二种创建线程的方式 public class ThreadDemo2 { public static void main(String[] args) { //实例化任务 Runnable r1 = new MyRunnable1();//多态 Runnable r2 = new MyRunnable2(); //MyRunnable r1 = new MyRunnable1(); //创建两条线程并指派任务 Thread t1 = new Thread(r1); Thread t2 = new Thread(r2); t1.start(); t2.start(); } } class MyRunnable1 implements Runnable{ public void run() { for (int i=0;i<1000;i++){ System.out.println("你是谁啊?"); } } } class MyRunnable2 implements Runnable{ public void run() { for (int i=0;i<1000;i++){ System.out.println("开门!查水表的!"); } } }//两个线程互补干涉，谁获得时间片谁执行
package thread;
/**
* 使用匿名内部类完成线程的两种创建
*/
public class ThreadDemo3 {
public static void main(String[] args) {
使用Thread的匿名类创建Thread实例
//第一种：继承Thread重写run方法
Thread t1 = new Thread(){
public void run(){
for(int i=0;i<1000;i++){
System.out.println("你是谁啊?");
}
}
};
使用Runnable的匿名类创建Runnable实例
//第二种：实现Runnable接口单独定义线程任务的形式
// Runnable r2 = new Runnable() {
// public void run() {
// for(int i=0;i<1000;i++){
// System.out.println("我是查水表的!");
// }
// }
// };
//Thread中因为方法众多，不能使用lambda表达式
//Runnable可以使用lambda表达式创建
Runnable r2 = ()->{
for(int i=0;i<1000;i++){
System.out.println("我是查水表的!");
}
};
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
java中的代码都是靠线程运行的，执行main方法的线程称为"主线程"。
* java中所有的代码都是靠线程运行的，main方法也不例外。 * java程序跑起来后，JVM会创建一条线程来执行main方法，这个线程的名字也叫"main",我们 * 通常称呼它为"主线程"。 * 我们自己定义的线程在不指定名字的情况下系统会分配一个名字，格式为"thread-x"(x是一个数)。
* Thread提供了一个静态方法: * static Thread currentThread() * 获取执行该方法的线程。
package thread;
public class CurrentThreadDemo {
public static void main(String[] args) {
/*
后期会学习到一个很重要的API:ThreadLocal,它可以使得我们在一个线程上跨越多个
方法时共享数据使用，其内部要用到currentThread方法来辨别线程。
如spring的事物控制就是靠ThreadLocal实现的。
*/
Thread main = Thread.currentThread();//获取执行main方法的线程(主线程)
System.out.println("主线程:"+main);//主线程:Thread[main,5,main]
dosome();//主线程执行dosome方法：
}
public static void dosome(){
Thread t = Thread.currentThread();//获取执行dosome方法的线程
System.out.println("执行dosome方法的线程是:"+t);
//执行dosome方法的线程是:Thread[main,5,main]
}
}
package thread;
/**
* 获取线程相关信息的一组方法
*/
public class ThreadInfoDemo {
public static void main(String[] args) {
Thread main = Thread.currentThread();//获取主线程
String name = main.getName();//获取线程的名字
System.out.println("名字:"+name);//main
long id = main.getId();//获取该线程的唯一标识
System.out.println("id:"+id);//1
int priority = main.getPriority();//获取该线程的优先级
System.out.println("优先级:"+priority);//5
boolean isAlive = main.isAlive();//该线程是否活着
System.out.println("是否活着:"+isAlive);//是否活着:true
boolean isDaemon = main.isDaemon();//是否为守护线程
System.out.println("是否为守护线程:"+isDaemon);//是否为守护线程:false
boolean isInterrupted = main.isInterrupted();//是否被中断了
System.out.println("是否被中断了:"+isInterrupted);//是否被中断:false
}
}
线程start后会纳入到线程调度器中统一管理,线程只能被动的被分配时间片并发运行,而无法主动索取时间片.线程调度器尽可能均匀的将时间片分配给每个线程.
线程有10个优先级,使用整数1-10表示
- 1为最小优先级,10为最高优先级.5为默认值
- 调整线程的优先级可以最大程度的干涉获取时间片的几率.优先级越高的线程获取时间片的次数越多,反之则越少.
package thread; public class PriorityDemo { public static void main(String[] args) { Thread max = new Thread(){ public void run(){ for(int i=0;i<10000;i++){ System.out.println("max"); } } }; Thread min = new Thread(){ public void run(){ for(int i=0;i<10000;i++){ System.out.println("min"); } } }; Thread norm = new Thread(){ public void run(){ for(int i=0;i<10000;i++){ System.out.println("nor"); } } }; min.setPriority(Thread.MIN_PRIORITY); max.setPriority(Thread.MAX_PRIORITY); min.start(); norm.start(); max.start(); } }//max线程优先级最高，可以最大程度优先获取时间片，先执行完毕，
//其次是nor默认优先级，最后是min属于最低优先级
线程提供了一个静态方法:
- static void sleep(long ms)
- 使运行该方法的线程进入阻塞状态指定的毫秒,超时后线程会自动回到RUNNABLE状态等待再次获取时间片并发运行.
package thread;
public class SleepDemo {
public static void main(String[] args) {
System.out.println("程序开始了!");
try {
Thread.sleep(5000);//主线程阻塞5秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("程序结束了!");
}
}
sleep方法处理异常:InterruptedException.
当一个线程调用sleep方法处于睡眠阻塞的过程中,该线程的interrupt()方法被调用时,sleep方法会抛出该异常从而打断睡眠阻塞.
package thread; /** * sleep方法要求必须处理中断异常:InterruptedException * 当一个线程调用sleep方法处于睡眠阻塞的过程中，它的interrupt()方法被调用时 * 会中断该阻塞，此时sleep方法会抛出该异常。 */ public class SleepDemo2 { public static void main(String[] args) { Thread lin = new Thread(){ public void run(){ System.out.println("林:刚美完容，睡一会吧~"); try { Thread.sleep(9999999); } catch (InterruptedException e) { System.out.println("林:干嘛呢!干嘛呢!干嘛呢!都破了像了!"); } System.out.println("林:醒了"); } }; Thread huang = new Thread(){ public void run(){ System.out.println("黄:大锤80!小锤40!开始砸墙!"); for(int i=0;i<5;i++){ System.out.println("黄:80!"); try { Thread.sleep(1000); } catch (InterruptedException e) { } } System.out.println("咣当!"); System.out.println("黄:大哥，搞定!"); lin.interrupt();//中断lin的睡眠阻塞 } }; lin.start(); huang.start(); } }/* 林:刚美完容，睡一会吧~
黄:大锤80！小锤40！开始砸墙!
黄:80！
黄:80！
黄:80！
黄:80！
黄:80！
咣当
黄:大哥！搞定！
林:干嘛呢！干嘛呢！干嘛呢！都破了相了!
林:醒了 */
守护线程也称为:后台线程
* 守护线程是通过普通线程调用方法setDaemon(true)设置而来的。 * 守护线程和普通线程的区别体现在一个结束时机上的不同:即进程的结束 * 进程的结束：当java进程中所有的普通线程都结束时，进程就会结束。 * 当进程结束时，进程会强制杀死所有正在运行的守护线程并最终停止。
package thread; public class DaemonThreadDemo { public static void main(String[] args) { Thread rose = new Thread(){ public void run(){ for(int i=0;i<5;i++){ System.out.println("rose:let me go!"); try { Thread.sleep(1000); } catch (InterruptedException e) { } } System.out.println("rose:啊啊啊啊啊啊AAAAAAAaaaaa...."); System.out.println("噗通"); } }; Thread jack = new Thread(){ public void run(){ while(true){ System.out.println("jack:you jump!i jump!"); try { Thread.sleep(1000); } catch (InterruptedException e) { } } } }; rose.start(); jack.setDaemon(true);//设置守护线程必须在线程启动前进行 jack.start();//将jack设置为守护线程 //while(true);//在主线程加一个死循环 //只要还有线程(包括main)在运行，守护线程就不会停止 //最典型的守护线程：GC垃圾回收器 } }/*
rose:let me go!
jack:you jump!i jump!
jack:you jump!i jump!
rose:let me go!
jack:you jump!i jump!
rose:let me go!
jack:you jump!i jump!
rose:let me go!
jack:you jump!i jump!
rose:let me go!
jack:you jump!i jump!
rose:啊啊啊啊啊啊AAAAAAaaaa.....
噗通!Process finished with exit code 0
*/
//当在主线程加上一个死循环：while(true);
/*
rose:let me go!
jack:you jump!i jump!
jack:you jump!i jump!
rose:let me go!
jack:you jump!i jump!
rose:let me go!
rose:let me go!
jack:you jump!i jump!
rose:let me go!
jack:you jump!i jump!
jack:you jump!i jump!
rose:啊啊啊啊啊啊AAAAAAaaaa.....
噗通!
jack:you jump!i jump!
... //主线程没有结束，那么守护线程不会结束，陷入死循环
jack:you jump!i jump!
通常当我们不关心某个线程的任务什么时候停下来,它可以一直运行,但是程序主要的工作都结束时它应当跟着结束时,这样的任务就适合放在守护线程上执行.比如GC就是在守护线程上运行的.
* 当多个线程并发操作同一临界资源，由于线程切换时机不确定，导致操作顺序出现了混乱，产生不正 常后果。 * 解决：将多个线程并发操作临界资源的过程改为同步操作就可以有效的解决多线程并发安全问题，相 当于让多个线程从原来的抢着操作改为排队操作。 * 临界资源:操作该资源的完整过程同一时刻只能有单个线程进行的
package thread; public class SyncDemo { public static void main(String[] args) { Table table = new Table(); Thread t1 = new Thread(){ public void run(){ while(true){ int bean = table.getBean(); Thread.yield(); System.out.println(getName()+":"+bean); } } }; Thread t2 = new Thread(){ public void run(){ while(true){ int bean = table.getBean(); /* static void yield() 线程提供的这个静态方法作用是让执行该方法的线程 主动放弃本次时间片。 这里使用它的目的是模拟执行到这里CPU没有时间了，发生 线程切换，来看并发安全问题的产生。 */ Thread.yield(); System.out.println(getName()+":"+bean); } } }; t1.start(); t2.start(); } } class Table{ private int beans = 20;//桌子上有20个豆子 public int getBean(){ if(beans==0){ throw new RuntimeException("没有豆子了!"); } Thread.yield();//让线程主动放弃本次时间片，用来模拟执行到这里时CPU没有时间了 return beans--; } }/*情况一：期望的结果
Thread-0:20
Thread-1:19...
Thread-0:2
Thread-1:1Exception in thread "Thread-0" Exception in thread "Thread-1" java.lang.RuntimeException: 没有豆子了! //抛出异常：属于期望结果
情况二：发生并发安全问题：
Thread-1:-28726
Thread-0:-28727
Thread-1:-28728... //陷入死循环
*/
synchronized有两种使用方式
- 在方法上修饰,此时该方法变为一个同步方法(可以是构造方法)
- 同步块,可以更准确的锁定需要排队的代码片段
当一个方法使用synchronized修饰后,这个方法称为"同步方法",
即:多个线程不能同时在方法内部执行(多个线程不能同时执行该方法)，只能有先后顺序的一个一个进行，将并发操作同一临界资源的过程改为同步执行就可以有效的解决并发安全问题.
package thread; public class SyncDemo { public static void main(String[] args) { Table table = new Table(); Thread t1 = new Thread(){ public void run(){ while(true){ int bean = table.getBean(); Thread.yield(); System.out.println(getName()+":"+bean); } } }; Thread t2 = new Thread(){ public void run(){ while(true){ int bean = table.getBean(); Thread.yield(); System.out.println(getName()+":"+bean); } } }; t1.start(); t2.start(); } } class Table{ private int beans = 20;//桌子上有20个豆子 public synchronized int getBean(){ if(beans==0){ throw new RuntimeException("没有豆子了!"); } Thread.yield();//让线程主动放弃本次时间片，用来模拟执行到这里时CPU没有时间了 return beans--; } }/使用同步方法后：解决了并发安全问题
Thread-0:20
Thread-1:19...
Thread-0:2
Thread-1:1Exception in thread "Thread-0" Exception in thread "Thread-1" java.lang.RuntimeException: 没有豆子了! //抛出异常：属于期望结果
同步块可以更准确的控制需要多个线程排队执行的代码片段.
有效的缩小同步范围可以在保证并发安全的前提下尽可能的提高并发效率.
同步监视器对象即上锁的对象，要想保证同步块中的代码被多个线程同步运行,则要求多个线程看到的同步监视器对象是同一个.
语法:
synchronized(同步监视器对象){ 需要多线程同步执行的代码片段 }
在方法上使用synchronized时，同步监视器对象就是当前方法的所属对象，即:this
package thread; public class SyncDemo2 { public static void main(String[] args) { Shop shop = new Shop();//同一个商店买衣服 Thread t1 = new Thread(){ public void run(){ shop.buy(); } }; Thread t2 = new Thread(){ public void run(){ shop.buy(); } }; t1.start(); t2.start(); } } class Shop{ /* 在方法上使用synchronized，那么同步监视器对象就是this。 */ public void buy(){ // public synchronized void buy(){ Thread t = Thread.currentThread();//获取运行该方法的线程 try { System.out.println(t.getName()+":正在挑衣服...");//挑衣服可以互不干涉 Thread.sleep(5000); /* 使用同步块需要指定一个同步监视器对象，即:上锁的对象 这个对象从语法的角度来讲可以是java中任何引用类型的实例，只要保证多个需 要排队执行该同步块中代码的线程看到的该对象是"同一个"即可 */ synchronized (this) { // synchronized (new Object()) {//没有效果!new Object是无效的,只要new一定不行 System.out.println(t.getName() + ":正在试衣服..."); //试衣服只能依次进行 Thread.sleep(5000); } System.out.println(t.getName()+":结账离开"); } catch (InterruptedException e) { e.printStackTrace(); } } }输出：Thread-1:正在挑衣服...
Thread-0:正在挑衣服...
Thread-0:正在试衣服...
Thread-0:结账离开
Thread-1:正在试衣服...
Thread-1:结账离开
实例一：
//单选题
//关于在下面代码的"?"处指定同步监视器保证线程同步，下列说法正确的_B__：
public class Demo {
public static void main(String[] args) {
Foo foo = new Foo();
Thread t1 = new Thread(){
public void run(){
foo.dosome();
}
};
Thread t2 = new Thread(){
public void run(){
foo.dosome();
}
};
t1.start();
t2.start();
}
}
class Foo{
public void dosome(){
try {
Thread t = Thread.currentThread();
System.out.println(t.getName()+":start...");
Thread.sleep(5000);
synchronized (?){
System.out.println(t.getName() + ":doing...");
Thread.sleep(5000);
}
System.out.println(t.getName()+":end...");
} catch (InterruptedException e) {
}
}
}
//A.可以指定整数1
//B.可以指定this
//C.可以指定new Object()
//D.可以指定t
/*
这里可以指定this，因为t1和t2线程调用的都是foo对象的dosome方法，因此方法中的this看到的都是该foo对象；
这里不能指定t的原因是，每个线程执行dosome方法时获取的t都是该线程自己，所以多个线程看到并非同一个对象；
这里不能指定new Object()的原因是，执行该实例化动作就会创建一个新的Object而对象，所以多个线程看到并非同一个对象；
这里不能指定整数1的原因是，整数1是基本类型，同步监视器对象必须指定引用类型。*/
当在静态方法上使用synchronized后,该方法是一个同步方法.由于静态方法所属类,所以一定具有同步效果.
静态方法使用的同步监视器对象为当前类的类对象(Class的实例).
注:类对象会在后期反射知识点介绍.
package thread; /** * 静态方法上如果使用synchronized，则该方法一定具有同步效果。 */ public class SyncDemo3 { public static void main(String[] args) { Thread t1 = new Thread(){ public void run(){ Boo.dosome(); } }; Thread t2 = new Thread(){ public void run(){ Boo.dosome(); } }; t1.start(); t2.start(); } } class Boo{ /** * synchronized在静态方法上使用是，指定的同步监视器对象为当前类的类对象。 * 即:Class实例。 * 在JVM中，每个被加载的类都有且只有一个Class的实例与之对应，后面讲反射 * 知识点的时候会介绍类对象。 * 静态方法没有隐式this，静态的类对象：Boo.class，只在静态方法中用类对象 */ public synchronized static void dosome(){ Thread t = Thread.currentThread(); try { System.out.println(t.getName() + ":正在执行dosome方法..."); Thread.sleep(5000); System.out.println(t.getName() + ":执行dosome方法完毕!"); } catch (InterruptedException e) { e.printStackTrace(); } } } }输出：Thread-0:正在执行dosome方法...
Thread-0:执行dosome方法完毕!
Thread-1:正在执行dosome方法...
Thread-1:执行dosome方法完毕!
静态方法中使用同步块时,指定的锁对象通常也是当前类的类对象
class Boo{
public static void dosome(){
/*
静态方法中使用同步块时，指定同步监视器对象通常还是用当前类的类对象
获取方式为:类名.class
*/
synchronized (Boo.class) {
Thread t = Thread.currentThread();
try {
System.out.println(t.getName() + ":正在执行dosome方法...");
Thread.sleep(5000);
System.out.println(t.getName() + ":执行dosome方法完毕!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
当多个线程执行不同的代码片段,但是这些代码片段之间不能同时运行时就要设置为互斥的.
使用synchronized锁定多个代码片段,并且指定的同步监视器是同一个时,这些代码片段之间就是互斥的.
package thread; /** * 互斥锁 * 当使用synchronized锁定多个不同的代码片段，并且指定的同步监视器对象相同时， * 这些代码片段之间就是互斥的，即:多个线程不能同时访问这些方法。 */ public class SyncDemo4 { public static void main(String[] args) { Foo foo = new Foo(); Thread t1 = new Thread(){ public void run(){ foo.methodA(); } }; Thread t2 = new Thread(){ public void run(){ foo.methodB(); } }; t1.start(); t2.start(); } } class Foo{ public synchronized void methodA(){ Thread t = Thread.currentThread(); try { System.out.println(t.getName()+":正在执行A方法..."); Thread.sleep(5000); System.out.println(t.getName()+":执行A方法完毕!"); } catch (InterruptedException e) { e.printStackTrace(); } } public synchronized void methodB(){ Thread t = Thread.currentThread(); try { System.out.println(t.getName()+":正在执行B方法..."); Thread.sleep(5000); System.out.println(t.getName()+":执行B方法完毕!"); } catch (InterruptedException e) { e.printStackTrace(); } } } 输出： Thread-0:正在执行A方法... Thread-0:执行A方法完毕! Thread-1:正在执行B方法... Thread-1:执行B方法完毕!//若是Foo foo1 = new Foo();
Foo foo2 = new Foo();
Thread1执行foo1.methodA，Thread2执行foo2.method，那么这两个线程不是同步的，不是一个对象，就谈不上是互斥的。
但如果将这两个方法同步块中synchronize中设置为类对象，即使是两个对象的线程，最后也会同步，同上述输出结果。所以不是静态方法，最好不要锁类对象。
package thread;
public class SyncDemo4 {
public static void main(String[] args) {
Foo foo1 = new Foo();
Foo foo2 = new Foo();
Thread t1 = new Thread(){
public void run(){
foo1.methodA();
}
};
Thread t2 = new Thread(){
public void run(){
foo2.methodB();
}
};
t1.start();
t2.start();
}
}
class Foo{
//互斥：看有没有上锁；看指定的锁对象是不是相同,静态方法锁定的是类对象
public synchronized void methodA(){
try{
Thread t = Thread.currentThread();
System.out.println(t.getName()+":正在执行A方法");
Thread.sleep(5000);
System.out.println(t.getName()+":执行A方法完毕");
}catch (Exception e){
}
}
public void methodB(){//若B没有上锁，那么在调B方法时就根本不用看调用的对象是否上锁
//成员方法，syn块锁定类对象不合适,当两个对象没有竞争关系时，调用该方法
//也显示互斥，不合理
synchronized (Foo.class) { //同步计数器：上锁的时候需要
try {
Thread t = Thread.currentThread();
System.out.println(t.getName() + ":正在执行B方法");
Thread.sleep(5000);
System.out.println(t.getName() + ":执行B方法完毕");
} catch (Exception e) {
}
}
}
}
/*
Thread-0:正在执行A方法
Thread-1:正在执行B方法
Thread-1:执行B方法完毕
Thread-0:执行A方法完毕
*/死锁的产生:
以两个线程为例：当两个线程各自持有一个锁的过程中等待对方先释放锁时就会形成一种僵持状态，导致程序卡住且无法再继续后面的执行，这个现象称为死锁。
package thread; /** * 死锁 * 死锁的产生: * 两个线程各自持有一个锁对象的同时等待对方先释放锁对象，此时会出现僵持状态。 * 这个现象就是死锁。 */ public class DeadLockDemo { //定义两个锁对象，"筷子"和"勺" public static Object chopsticks = new Object(); public static Object spoon = new Object(); public static void main(String[] args) { Thread np = new Thread(){ public void run(){ System.out.println("北方人开始吃饭."); System.out.println("北方人去拿筷子..."); synchronized (chopsticks){ System.out.println("北方人拿起了筷子开始吃饭..."); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("北方人吃完了饭，去拿勺..."); synchronized (spoon){ System.out.println("北方人拿起了勺子开始喝汤..."); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("北方人喝完了汤"); } System.out.println("北方人放下了勺"); } System.out.println("北方人放下了筷子，吃饭完毕!"); } }; Thread sp = new Thread(){ public void run(){ System.out.println("南方人开始吃饭."); System.out.println("南方人去拿勺..."); synchronized (spoon){ System.out.println("南方人拿起了勺开始喝汤..."); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("南方人喝完了汤，去拿筷子..."); synchronized (chopsticks){ System.out.println("南方人拿起了筷子开始吃饭..."); try { Thread.sleep(5000); } catch (InterruptedException e) { } System.out.println("南方人吃完了饭"); } System.out.println("南方人放下了筷子"); } System.out.println("南方人放下了勺，吃饭完毕!"); } }; np.start(); sp.start(); } }/*
北方人:开始吃饭
南方人:开始吃饭
南方人去拿勺...
南方人拿起了勺，开始喝汤...
北方人去拿筷子...
北方人拿起了筷子，开始吃饭...
南方人喝完了汤，去拿筷子...
北方人吃完了饭，去拿勺...//后面形成僵持状态，程序没有结束...
*/
解决死锁:
1：尽量避免在持有一个锁的同时去等待持有另一个锁(避免synchronized嵌套)
2：当无法避免synchronized嵌套时，就必须保证多个线程锁对象的持有顺序必须一致。
即:A线程在持有锁1的过程中去持有锁2时,B线程也要以这样的持有顺序进行。
package thread; /** * 解决死锁: */ public class DeadLockDemo2 { //筷子 private static Object chopsticks = new Object(); //勺 private static Object spoon = new Object(); public static void main(String[] args) { //北方人 Thread np = new Thread(){ public void run(){ try { System.out.println("北方人:开始吃饭"); System.out.println("北方人去拿筷子..."); synchronized (chopsticks) { System.out.println("北方人拿起了筷子，开始吃饭..."); Thread.sleep(5000); } System.out.println("北方人吃完了饭，放下了筷子"); System.out.println("北方人去拿勺子..."); synchronized (spoon){ System.out.println("北方人拿起了勺子，开始喝汤..."); Thread.sleep(5000); } System.out.println("北方人喝完了汤,北方人放下了勺子"); System.out.println("吃饭完毕。"); } catch (InterruptedException e) { e.printStackTrace(); } } }; //南方人 Thread sp = new Thread(){ public void run(){ try { System.out.println("南方人:开始吃饭"); System.out.println("南方人去拿勺..."); synchronized (spoon) { System.out.println("南方人拿起了勺，开始喝汤..."); Thread.sleep(5000); } System.out.println("南方人喝完了汤，放下勺子..."); System.out.println("南方人去拿筷子..."); synchronized (chopsticks){ System.out.println("南方人拿起了筷子，开始吃饭..."); Thread.sleep(5000); } System.out.println("南方人吃完了饭,南方人放下了筷子"); System.out.println("吃饭完毕。"); } catch (InterruptedException e) { e.printStackTrace(); } } }; np.start(); sp.start(); } }/*
北方人:开始吃饭
北方人去拿筷子...
北方人拿起了筷子，开始吃饭...
南方人:开始吃饭
南方人去拿勺...
南方人拿起了勺，开始喝汤...
北方人吃完了饭，放下了筷子
北方人去拿勺子...
北方人拿起了勺子，开始喝汤...
南方人喝完了汤，放下勺子...
南方人去拿筷子...
南方人拿起了筷子，开始吃饭...
南方人吃完了饭,南方人放下了筷子
吃饭完毕。
北方人喝完了汤,北方人放下了勺子
吃饭完毕。进程已结束,退出代码0
*/
线程池是线程的管理机制，它主要解决两方面问题:
1:复用线程
2:控制线程数量
JUC：指的是java.util.concurrent这个包，java的并发包，里面都是与多线程相关的API。线程池就在这个包里。
关闭线程池的两个操作: shutdown() 该方法调用后，线程不再接收新任务，如果此时还调用execute()则会抛出异常 并且线程池会继续将已经存在的任务全部执行完毕后才会关闭。 shutdownNow() 强制中断所有线程，来停止线程池
public class ThreadPoolDemo {
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(2);
//创建一个固定大小的线程池，容量为2
for(int i=0;i<5;i++){//分配了5个线程任务
Runnable r = new Runnable() {
public void run() {
Thread t = Thread.currentThread();//运行当前任务的线程
System.out.println(t.getName()+":正在执行一个任务...");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t.getName()+":执行一个任务完毕了");
}
};
threadPool.execute(r);
System.out.println("交给线程池一个任务...");
}
//shutdown()演示：
threadPool.shutdown();
System.out.println("线程池关闭了");
/*
交给线程池一个任务...
交给线程池一个任务...
交给线程池一个任务...
交给线程池一个任务...
交给线程池一个任务...
pool-1-thread-1:正在执行一个任务...
线程池关闭了 //主线程执行完毕了
pool-1-thread-2:正在执行一个任务...
pool-1-thread-2:执行一个任务完毕了！
pool-1-thread-1:执行一个任务完毕了！
pool-1-thread-2:正在执行一个任务...
pool-1-thread-1:正在执行一个任务...
pool-1-thread-2:执行一个任务完毕了！
pool-1-thread-1:执行一个任务完毕了！
pool-1-thread-1:正在执行一个任务...
pool-1-thread-1:执行一个任务完毕了！
*/
//shutdownNow()演示:
threadPool.shutdownNow();
System.out.println("线程池关闭了");
/*
交给线程池一个任务...
交给线程池一个任务...
交给线程池一个任务...
交给线程池一个任务...
交给线程池一个任务...
线程池关闭了 //主线程执行完毕了
pool-1-thread-2:正在执行一个任务...
pool-1-thread-1:正在执行一个任务...
pool-1-thread-2:执行一个任务完毕了！ //提前将分配的两个线程任务结束
pool-1-thread-1:执行一个任务完毕了！ //执行完前两个线程任务，后面的任务不会再执行
java.lang.InterruptedException: sleep interrupted //sleep的阻塞方法被提前中断，抛出异常
java.lang.InterruptedException: sleep interrupted
}
}