一、什么是线程
- 进程：操作系统中每个独立执行的程序都可称为一个进程。
- 线程：一个程序中能够同时运行的执行单元。
例：如果将QQ看作一个进程，则其中同时打开的聊天窗口则可看为一个个线程。
注：多线程程序运行时，每个线程之间是独立的，可以并发执行。但并不是同时执行，CPU同一时刻只能执行一个线程。
二、创建线程的两种方式
1、继承Thread类
Thread类位于java.lang包下，通过覆写Thread类的run()方法实现多线程。
示例：
public class Example_1 { public static void main(String[] args) { MyThread one = new MyThread(); one.start(); while(true){ System.out.println("main()方法在运行！"); } } } class MyThread extends Thread{ //重写run()方法 public void run(){ while(true){ System.out.println("MyThread类的run()方法在运行！"); } } }
注：有局限性，Java中一个类只能继承一个父类。
2、实现Runnable接口
其中只有一个run方法，通过构造函数Thread(Runnable target)创建线程对象。避免了局限性。
示例：
public class Example_2 { public static void main(String[] args) { MyThread_2 two = new MyThread_2(); //创建MyThread_2实例对象 Thread thread = new Thread(two); //创建线程对象 thread.start(); //开启线程 while(true){ System.out.println("main()方法在运行！"); } } }class MyThread_2 implements Runnable{ public void run(){ while(true){ System.out.println("MyThread_2类的run()方法在运行"); } } }
3、两种方式的对比
实现Runnable接口相对于继承Thread类来说有以下好处：
① 适合多个相同程序代码的线程取处理同一个资源的情况，把线程同程序代码，数据有效的分离，体现了面向对象的特点。
② 可以避免由于java的单继承带来的局限性。
示例：
public class Example_2 { public static void main(String[] args) { new TicketWindow().start(); //创建一个线程对象TicketWindow并开启 new TicketWindow().start(); //创建一个线程对象TicketWindow并开启 new TicketWindow().start(); //创建一个线程对象TicketWindow并开启 new TicketWindow().start(); //创建一个线程对象TicketWindow并开启 //TicketWindow_2 tw = new TicketWindow_2(); //创建TicketWindow_2实例对象 //new Thread(tw,"窗口1").start(); //创建线程并命名，开启线程 //new Thread(tw,"窗口2").start(); //创建线程并命名，开启线程 //new Thread(tw,"窗口3").start(); //创建线程并命名，开启线程 //new Thread(tw,"窗口4").start(); //创建线程并命名，开启线程 } } class TicketWindow extends Thread{ private int tickets = 100; public void run(){ while(true){ //通过死循环打印语句 if(tickets > 0){ Thread th = Thread.currentThread(); //获取当前线程 String th_name = th.getName(); //获取当前线程的名字 System.out.println(th_name + "正在发售第" + tickets-- + "张票"); } } } } class TicketWindow_2 implements Runnable{ private int tickets = 100; public void run(){ while(true){ //通过死循环打印语句 if(tickets > 0){ Thread th = Thread.currentThread(); //获取当前线程 String th_name = th.getName(); //获取当前线程的名字 System.out.println(th_name + "正在发售第" + tickets-- + "张票"); } } } }
4、后台线程
在java程序中，只要还有一个前台程序在运行，这个线程就不会结束，如果一个程序中只有后台线程运行，这个进程就会结束。
①新创建的线程默认都是前台线程
②如果某个线程对象在启动之前调用了setDaemon(true)语句，这个线程就变成一个后台线程。
注意：要将某个线程设置为后台线程，必须在该线程启动之前，也就是说setDaemon()方法必须在start()方法之前调用。否则会引发
IllegalThreadStateException异常。
代码：
class DamonThread implements Runnable{ public void run(){ while(true){ System.out.println(Thread.currentThread().getName() + "---is running."); } } } public class Example_3 { public static void main(String[] args) { System.out.println("main线程是后台线程么？" + Thread.currentThread().isDaemon()); DamonThread one = new DamonThread(); //创建一个DamonThread实例对象 Thread thread = new Thread(one,"后台线程"); //创建线程thread共享one资源 System.out.println("thread线程是后台线程么？" + Thread.currentThread().isDaemon()); thread.setDaemon(true); //将线程thread设为后台线程 thread.start(); //开启thread线程 for(int i = 0; i < 10; i++){ System.out.println(i); } } }
三、线程的生命周期
从Thread对象创建完毕开始，当run()方法中代码正常执行完毕或者抛出一个未捕获的异常(Exception)或者错误(Error)时，线程的生命周期便会结束。
①、新建状态(New)
创建一个线程后，该线程对象就处于就绪状态。仅仅由Java虚拟机为其分配了内存，不能运行。
②、就绪状态(Runnable)
当线程对象调用了start()方法后，该进程就进入就绪状态。处于就绪状态的线程位于可运行池中，此时它只是具备了运行的条件。
③、运行状态(Running)
如果处于就绪状态的线程获得了CPU的使用权，开始执行run()方法中的线程执行体，则该线程处于运行状态。
注：只有处于就绪状态的线程才可能转换到运行状态。
④、阻塞状态(Blocked)
一个正在执行的线程在某些特殊情况下，如执行耗时的输入/输出操作时，会放弃CPU使用权，进入阻塞状态。
注：线程进入阻塞状态后就不能进入排队队列。只有当引起阻塞原因被消除后，线程才可以转入就绪状态。
线程由运行状态转化成阻塞状态的原因，及如何从阻塞状态转换为就绪状态：
- 当线程需要从其他线程获取某个对象的同步锁时，如果该锁被其他线程所持有，则当前线程进入阻塞状态。如果想从阻塞状态进入就绪状态必须得获取到其他线程所持有的锁。
- 当线程调用了一个阻塞式的IO方法时，该线程进入阻塞状态，如果想进入就绪状态就必须等到这个阻塞的IO方法返回。
- 当线程调用了某个对象的wait()方法时，该线程进入阻塞状态，可使用notyfy()方法唤醒该线程使其进入就绪状态。
- 当线程调用了Thread的sleep(long millis)方法时，线程进入阻塞状态，需等线程睡眠时间到了以后，线程就会自动进入就绪状态。
- 当在一个线程中调用了另一个线程的join()方法时，会使当前线程进入阻塞状态，需要等到新加入的线程运行结束后才会结束阻塞状态进入就绪状态。
⑤、死亡状态(Terminated)
线程的run()方法正常执行完毕或者线程抛出一个未捕获的异常(Exception)、错误(Error)，线程就进入死亡状态。
注：一旦进入死亡状态，线程将不再拥有运行的资格，也不能再转换到其他其他状态。
四、线程的调度
即Java虚拟机按照特定的机制为程序中的每个线程分配CPU的使用权，这种机制称为线程的调度。
1、线程的优先级
线程的优先级用1-10之间的整数来表示，数字越大优先级越高。可以用Thread类中提供的静态常量来表示线程的优先级。
Thread类的优先级常量：
static int MAX_PRIORITY 表示线程的最高优先级，相当于值10
static int MIN_PRIORITY 表示线程的最低优先级，相当于1
static int NORM_PRIORITY 表示线程的普通优先级，相当于5
注：main线程具有普通优先级。可以通过Thread类的setPriority(int newPriority)方法对其进行设置。
示例：
class MaxPriority implements Runnable{ public void run(){ for(int i=0; i<=10; i++){ System.out.println(Thread.currentThread().getName() + "正在输出" + i); } } } class MinPriority implements Runnable{ public void run(){ for(int i=0; i<=10; i++){ System.out.println(Thread.currentThread().getName() + "正在输出" + i); } } } public class Example_4 { public static void main(String[] args) { //创建两个线程 Thread minPriority = new Thread(new MinPriority(),"优先级较低的线程"); Thread maxPriority = new Thread(new MaxPriority(),"优先级较高的线程"); minPriority.setPriority(Thread.MIN_PRIORITY); maxPriority.setPriority(10); //开启两个线程 maxPriority.start(); minPriority.start(); } }
2、线程休眠
可以通过静态方法sleep(long millis)将CPU让给别的线程，该方法可以让当前正在执行的线程暂停一段时间，进入休眠等待状态。
注：sleep(long millis)方法声明抛出InterruptedException异常，因此调用该方法时应该捕捉异常，或者声明抛出该异常。
示例：
class SleepThread implements Runnable{ public void run(){ for(int i=0; i<=10; i++){ if(i == 3){ try{ Thread.sleep(200); }catch(InterruptedException e){ e.printStackTrace(); } } System.out.println("线程一正在输出：" + i); try{ Thread.sleep(500); }catch(InterruptedException e){ e.printStackTrace(); } } } } public class Example_5 { public static void main(String[] args) throws InterruptedException { //创建一个线程 new Thread(new SleepThread()).start(); for(int i=1; i<=10; i++){ if(i == 5){ Thread.sleep(2000); } System.out.println("主线程正在输出" + i); Thread.sleep(500); } } }
注：sleep()是静态方法，只能控制当前正在运行的线程休眠，而不能控制其他线程休眠。
3、线程让步
线程让步可以通过yield()方法来实现，该方法和sleep()方法有点相似，区别是yield()方法不会阻塞该线程，它只是将线程转换成就绪状态让系统重新调度一次。
注：当某个线程调用yield()方法之后，只有与当前线程优先级相同或者更高的线程才能获得执行的机会。
示例：
class YieldThread extends Thread{ public YieldThread(String name){ super(name); //调用父类构造方法 } public void run(){ for(int i=0; i<=500; i++){ System.out.println(Thread.currentThread().getName() + "---" + i); if(i == 3){ System.out.println("线程让步："); Thread.yield(); //线程运行到此，做出让步 } } } } public class Example_6 { public static void main(String[] args) { //创建两个线程 Thread one = new YieldThread("线程A"); Thread two = new YieldThread("线程B"); //开启线程 one.start(); two.start(); } }
4、线程插队
在Thread类中提供了一个join()方法来实现“插队”，即当在某个线程中调用其他线程的join()方法时，调用的线程将被阻塞，直到被join()方法加入的线程执行完毕后它才会继续运行。
示例：
class EmergencyThread implements Runnable{
public void run(){
for(int i=0; i<10; i++){
System.out.println(Thread.currentThread().getName() + "输入：" + i);
try{
Thread.sleep(500);
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
public class Example_7 {
public static void main(String[] args) throws Exception {
//创建线程
Thread thread = new Thread(new EmergencyThread(),"线程一");
thread.start(); //开启线程
for(int i=0; i<10; i++){
System.out.println(Thread.currentThread().getName() + "输入：" + i);
if(i == 2){
thread.join(); //调用join()方法
}
Thread.sleep(500);
}
}
}
五、多线程同步
为了解决多个线程访问统一个资源时引发的一些安全问题。
解决方法：实现多线程的同步，即限制某个资源在同一时刻只能被一个线程访问。
1、同步代码块
同步代码块：同步机制
当多个线程使用一个共享资源时，可以将处理共享资源的代码放在一个代码块中，使用synchronized关键字来修饰，被称作同步代码块
语法格式：
synchronized(lock){
操作共享资源代码块
}
* #lock是一个锁对象是同步代码块的关键
* #锁对象的类型可以是任意类型的对象，但多个线程共享的锁对象必须是唯一的
* #锁对象的创建代码不能放到run()方法中。
示例：
class SaleThread implements Runnable{
private int tickets = 10;
Object lock = new Object(); //定义任意一个对象,作为同步代码块的锁
public void run(){
while(true){
synchronized(lock){ //定义同步代码块
try{
Thread.sleep(10);
}catch(InterruptedException e){
e.printStackTrace();
}
if(tickets > 0){
System.out.println(Thread.currentThread().getName() + "---卖出的票" + tickets--);
}else{
break;
}
}
}
}
}
public class Example_8 {
public static void main(String[] args) {
SaleThread one = new SaleThread(); //创建saleThread对象
//创建并开启四个线程
new Thread(one,"线程一").start();
new Thread(one,"线程二").start();
new Thread(one,"线程三").start();
new Thread(one,"线程四").start();
}
}
2、同步方法
方法前面同样可以使用synchronized关键字来修饰，被修饰的方法为同步方法，能实现和同步代码块相同的功能。
具体格式为：
synchronized 返回值类型 方法名([参数 1, ......]){}
被synchronized修饰的方法某一时刻值允许一个线程访问，访问该方法的其他线程都会发生阻塞，直到当前线程访问完毕后，其他线程才有机会执行方法。
示例：
class Ticket1 implements Runnable{ private int tickets = 10; public void run(){ while(true){ saleTicket(); if(tickets <= 0){ break; } } } private synchronized void saleTicket(){ if(tickets > 0){ try{ Thread.sleep(10); }catch(InterruptedException e){ e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "---卖出的票" + tickets--); } } } public class Example_9 { public static void main(String[] args) { Ticket1 ticket = new Ticket1(); //创建并开启四个线程 new Thread(ticket,"线程一").start(); new Thread(ticket,"线程二").start(); new Thread(ticket,"线程三").start(); new Thread(ticket,"线程四").start(); } }
注：同步方法也有锁，它的锁就是当前调用该方法的对象，也就是this指向的对象。
优点：同步方法被所有线程所共享，方法所在的对象相对于所有线程来说是唯一的，从而保证了锁的唯一性。
3、死锁问题
死锁问题:两个线程运行时都在等待对方的锁，这样便造成了程序的停滞，这种现象称为死锁。
示例：
public class Example_10 { public static void main(String[] args) { //创建两个DeadLockThread对象 DeadLockThread one = new DeadLockThread(true); DeadLockThread two = new DeadLockThread(false); //创建并开启两个线程 new Thread(one,"Chinese").start(); new Thread(two,"American").start(); } } class DeadLockThread implements Runnable{ static Object chopsticks = new Object(); //定义Object类型的chopsticks对象 static Object knifeAndFork = new Object(); //定义Object类型的knifeAndFork对象 private boolean flag; //定义布尔类型变量flag DeadLockThread(Boolean flag){ this.flag = flag; } public void run() { if(flag){ while(true){ synchronized(chopsticks){ //chopsticks锁对象上的同步代码块 System.out.println(Thread.currentThread().getName()+"---if---chopsticks"); synchronized(knifeAndFork){ System.out.println(Thread.currentThread().getName()+"---if---knifeAndFork"); } } } }else{ while(true){ synchronized(knifeAndFork){ //knifeAndFork锁对象上的同步代码块 System.out.println(Thread.currentThread().getName()+"---else---knifeAndFork"); synchronized(chopsticks){ System.out.println(Thread.currentThread().getName()+"---else---chopsticks"); } } } } } }