进程是一个正在执行中的程序。每一个进程执行都有一个执行顺序,该执行顺序是一个执行路径,或者叫一个控制单元。
线程就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
在计算机中多个线程都获取cpu的执行权,cpu执行到谁,谁就运行,明确一点,在某一个时刻,只能由一个程序运行(多核除外),cpu做着快速切换,以达到看上去是同事运行的效果。我们可以形象的把多线程的运行行为在互相抢夺cpu的执行权,这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长时间,cpu说了算。
public class ThreadDemo extends Thread {
public static void main(String[] args) {
Thread thread1 = new Thread();
Thread thread2 = new Thread();
thread1.start();
thread2.start();
}
}
class ThreadTest extends Thread {
@Override
public void run() {
/**
* 这里是要实现多线程的代码
*/
}
}
public class ThreadDemo extends Thread {
public static void main(String[] args) {
ThreadTest tt = new ThreadTest();
Thread thread1 = new Thread(tt);
Thread thread2 = new Thread(tt);
thread1.start();
thread2.start();
}
}
class ThreadTest implements Runnable {
@Override
public void run() {
/**
* 这里是要实现多线程的代码
*/
}
}
为什么要将Runnable接口的子类对象传递给Thread的构造函数?
因为自定义的run方法所属的对象是Runnable接口的子类对象,所以要让线程去指定指定对象的run方法
为什么要覆盖run方法?
Thread类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法,也就是说Thread类中的run方法,用于存储线程要运行的代码。
当使用new关键字新建了一个线程之后,该线程就属于新建状态,这个时候的它和其他Java对象一样,仅仅由JAVA虚拟机为它分配内存,并初始化它的值。
调用start()方法之后,该线程属于就绪状态,表示该线程可以运行了,但是何时运行得看JVM的内部调度。
当线程取得执行权限,run方法内的线程体开始执行时,该线程出于运行状态。
sleep(time)方法可以让线程冻结time长度的时间,time之后,继续执行线程。
wait()方法也可以冻结线程,冻结之后,需要notify()方法唤醒线程,否则会一直冻结。
run方法内部代码执行完毕或者遇到异常或error时候,线程结束,线程进入死亡状态。
stop()方法可以直接杀掉线程,但容易导致死锁,通常不推荐。
当同时运行多个线程时候,而cpu只能运行一个线程,那么其他线程就会先进入临时状态(阻塞状态)
火车站卖票就是一个典型的多线程的例子,票的总量是固定的,但是会有多个窗口在卖票,假设一共有100张票,一共有6个窗口在售票,当有人来买票的时候,窗口售票员先看是否有余票,如果有,则出售。
//使用实现Runnable接口方式实现
public class SellTicket {
public static void main(String[] args) {
TicketThread tt = new TicketThread();
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.start();
t2.start();
}
}
class TicketThread implements Runnable {
public int ticketCount = 100;
@Override
public void run() {
while (true) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
}
public void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//使用继承Thread类实现
public class SellTicket {
public static void main(String[] args) {
TicketThread tt1 = new TicketThread();
TicketThread tt2 = new TicketThread();
tt1.start();
tt2.start();
}
}
class TicketThread extends Thread {
public static int ticketCount = 100;
@Override
public void run() {
while (true) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
}
public void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
多执行几次的话,就会发现,会发生一票多卖的情况,是因为线程获取到CPU的执行权限之后做运算,还没有将票数减少,另外一个线程抢夺到了CPU的执行权限,所以他们卖出的是同一张票,这个时候就出现了问题,为了解决这个问题,JAVA的多线程支持引入了同步监视器来解决这个问题。
JAVA使用synchronized关键字在线程开始执行同步代码快之前,获取对同步监视器的锁定
public void run() {
method();
}
public void method () {
synchronized (this){
同步代码段
}
}
注意,普通方法中的同步对象是this,静态方法中的同步对象是 类名.class
public class SellTicket {
public static void main(String[] args) {
TicketThread tt = new TicketThread();
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.start();
t2.start();
}
}
class TicketThread implements Runnable {
public int ticketCount = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
}
}
public void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
public void run() {
method();
}
public synchronized void method () {
同步代码段
}
package cn.lixyz.thread;
public class SellTicket {
public static void main(String[] args) {
TicketThread tt = new TicketThread();
Thread t1 = new Thread(tt);
Thread t2 = new Thread(tt);
t1.start();
t2.start();
}
}
class TicketThread implements Runnable {
public int ticketCount = 100;
@Override
public void run() {
while (true) {
sellTicket();
if (ticketCount == 0) {
break;
}
}
}
public synchronized void sellTicket() {
if (ticketCount > 0) {
System.out.println(Thread.currentThread().getName() + " 卖了第 "
+ ticketCount-- + " 张票");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
使用synchronized修饰的代码就好比拥有了一把锁,当线程对象开始执行同步内容代码时,其他线程即时获取了CPU的执行权限也无法执行,直到当前执行对象执行完毕释放权限。