本人的GitHub:戳我一下
一、进程和线程
进程:是一个正在执行的程序,每一个进程都有一个独立的内存空间。
线程:是进程中的一个独立的控制单元,一个进程中所有的线程共用一个内存空间。
关系:一个进程至少包含一个线程,线程是进程的一部分。
二、创建一个线程
创建线程有两种方法:
1、继承Thread
类,并覆写run()
方法:
class Demo extends Thread {
public void run() {
System.out.println("haha");
}
}
class ThreadDemo {
public static void main(String[] args) {
Demo d = new Demo();//创建好一个线程
d.start();//启动线程
}
}
2、实现Runnable
接口:
class Demo implements Runnable {
public void run() {
System.out.println("haha");
}
}
class RunnableDemo {
public static void main(String[] args) {
Demo d = new Demo();
new Thread(d).start();
}
}
三、线程的四种状态及状态间的转换
1、被创建:线程刚被创建,还没有start()
2、运行:线程已经start()
,且正在运行
3、阻塞:线程已经start()
,但是没有运行资格,等待别的线程运行,当别的线程运行时间结束,就可以运行
4、死亡:该线程死亡,无法运行。
5、冻结:线程通过wait()
sleep()
等方法放弃了执行的资格,等待被唤醒。
四、线程安全问题
首先先看个示例:这是一个模拟卖票的小程序,我们可以发现代码中只有100张票,如果线程安全,那么4个线程一共应该卖出100张票,并且1~100各一张
public class TickeDemo {
public static void main(String[] args) throws InterruptedException {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket implements Runnable {
private static int tick = 100;
public void run() {
while(tick > 0) {
try {
if(tick > 0)
System.out.println(Thread.currentThread().getName() + "..." + tick--);
else break;
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
运行结果部分截取:
运行结果分析:
发现出现了一张票被卖多次的情况出现,出现这种情况的原因是当一个线程在操作tick
这个共享数据时,突然被阻塞,然后另一个线程进来操作tick
导致出现共享数据的错误。
解决办法:
对共享数据操作的过程中,只能让一个线程操作共享数据,只有该线程操作完成后,下一个线程才能继续执行。java对线程安全问题提供了解决的方法,就是同步代码块:
synchronized(对象) {
//操作共享数据的代码块
}
对象如同锁,只有持有锁的线程才能执行同步代码块中的代码
解决问题后的代码:
public class TickeDemo {
public static void main(String[] args) throws InterruptedException {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Ticket implements Runnable {
private static int tick = 100;
Object obj = new Object();
public void run() {
while(true) {
synchronized(obj) {
if(tick > 0)
System.out.println(Thread.currentThread().getName() + "..." + tick--);
else break;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
同步的前提:
1、必须有两个或两个以上的线程
2、必须使用的是同一个锁
如何判断代码是否需要同步:
1、明确那些代码是多线程运行代码
2、明确共享数据
3、明确多线程代码中那些是操作共享数据的
synchronized
可以作为修饰符修饰一个函数,使该函数具备同步性,例如:
public synchronized void function() {
sum += 1;
System.out.println(sum);
}
其中,sum
是共享数据,这个函数是同步的,线程安全。
四、锁
上面提到的synchronized(对象)
中的对象就是锁,这个锁可以是任何对象,而用synchronized
修饰的函数使用的是this
这个对象来做锁,如果这个函数是静态的,那么它的锁是对象名.Class
对象。
如果一个共享数据在不同的操作中使用了不同的锁,那么该代码就不是线程安全的,举个例子:还是卖票的例子,不过代码有些变化,这次增加了一个show()
函数,两个线程用了不同的锁,其中if
语句中使用的是obj
这个对象锁,而show()
函数使用的是this
这个对象锁
public class TickeDemo {
public static void main(String[] args) throws InterruptedException {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
Thread.sleep(100);
t.flag = false;
t2.start();
}
}
class Ticket implements Runnable {
private static int tick = 100;
boolean flag = true;
Object obj = new Object();
public void run() {
if(flag) {
while(true) {
synchronized(obj) {
if(tick > 0)
System.out.println(Thread.currentThread().getName() + "...code..." + tick--);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
else {
while(true) {
show();
}
}
}
public synchronized void show() {
if(tick > 0)
System.out.println(Thread.currentThread().getName() + "...show...." + tick--);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行结果截取:
结果分析:
可以看出,代码并不是线程安全的,如果想要使代码变成安全的,那么只需要把synchronized(obj)
换成synchronized(this)
,就可以了。
五、线程间的通信——等待唤醒机制
1、我们通过看java文档可以发现Object
类中有wait()
notify()
notifyAll()
三种方法,我们就是通过这三个方法来实现线程间的通信操作。
2、wait()
方法可以让该线程进入冻结状态,在没被唤醒期间该线程不会运行。
3、notify()
方法可以随机唤醒一个线程。
notifyAll()
方法可以唤醒所有被冻结的线程。
4、注意这里的三个方法都是通过锁来操作的,假如我们有一个Object
对象锁叫obj
,有甲和乙两个线程,这里我们通过obj.wait()
将甲线程冻结,然后我们可以用obj.notifyAll()
将甲线程唤醒,notifyAll()
只能唤醒同一个锁冻结的线程,如果还有一个锁this
,那么我们是不可以用this.notifyAll()
来唤醒被obj
冻结的线程的。
这里可以通过生产者消费者的例子来理解,下面是代码:
public class ProducerConsumerDemo {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
//注意这里t1 t2 是生产者,t3 t4是消费者
}
}
class Resource {
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name) {
while(flag) {
try {
this.wait();
} catch (Exception e) {
// TODO: handle exception
}
}
this.name = name + "---" + count++;
System.out.println(Thread.currentThread().getName()+"----------生产者"+this.name);
flag = true;
this.notifyAll();
}
public synchronized void out() {
while(!flag) {
try {
this.wait();
} catch (Exception e) {
// TODO: handle exception
}
}
System.out.println(Thread.currentThread().getName()+"--消费者"+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable {
private Resource res;
Producer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
res.set("+商品+");
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
}
}
}
class Consumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
res.out();
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
}
}
}
六、其他
1、停止线程
停止线程只有一种方法,就是run
方法的代码结束,我们一般把多线程用于循环中,我们通过控制循环就可以控制多线程,这里需要注意一种情况,那就是如果主线程已经结束,但是其他的线程都冻结了,那么程序就挂起了,我们只能通过手动关闭程序,这种情况无疑是非常糟糕的,比如下面这段代码,运行之后就会发现,当主线程结束后,程序没有结束,就是因为其他的两个线程都冻结了,这里我们就需要考虑怎么将冻结的程序唤醒。
public class StopThreadDemo {
public static void main(String[] args) {
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
for(int i=0;i<60;i++) {
System.out.println(Thread.currentThread().getName() + "--------main" + i);
}
st.changeFlag();
}
}
class StopThread implements Runnable {
private boolean flag = true;
public synchronized void run() {
while(flag) {
try {
this.wait();
} catch (Exception e) {
System.out.println(Thread.currentThread().getName() + "--------interrupt");
}
System.out.println(Thread.currentThread().getName() + "--------run");
}
}
public void changeFlag() {
this.flag = false;
}
}
我们可以用interrupt()
方法来处理这种情况,这个方法可以让冻结中的线程强制的苏醒,注意interrupt()
方法会报一个InterruptedException
错误,上面的例子就可以改为:
public class StopThreadDemo {
public static void main(String[] args) {
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
for(int i=0;i<60;i++) {
System.out.println(Thread.currentThread().getName() + "--------main" + i);
}
st.changeFlag();
t1.interrupt();
t2.interrupt();
System.out.println("over");
}
}
class StopThread implements Runnable {
private boolean flag = true;
public synchronized void run() {
while(flag) {
try {
this.wait();
} catch (Exception e) {
System.out.println(Thread.currentThread().getName() + "--------interrupt");
}
System.out.println(Thread.currentThread().getName() + "--------run");
}
}
public void changeFlag() {
this.flag = false;
}
}
运行结果截图
2、守护线程
我们可以通过setDaemo()
方法来将一个线程设置为守护线程,守护线程的特性是:当非守护线程都停止运行后,守护线程自动停止。
3、join
方法
join
方法可以让当前的线程退出运行,直到调用join
方法的线程停止,才继续运行,这里举个例子,加入有甲乙丙三个线程,其中甲正在运行,这时,乙调用了join
方法,那么甲就会停止运行,然后乙和丙轮流执行,直到乙运行结束,甲才能运行,此时如果丙没有运行完,就是甲和丙轮流执行。
4、优先级和yield
方法
这里的优先级很好理解,就是那个线程的优先级高,cpu就优先运行那么线程,可以通过setPriority()
方法来设置优先级,注意优先级只有(1~10)默认是“5”。
yield
方法的功能是停止当前的线程,转去执行其他的线程。