从卖票入手
先看多线程的一个经典例子:创建三个窗口卖票,总票数是100张。
先看这个代码:
package com.xzc;
class Window extends Thread{
public Window(){
}
public Window(String name){
super(name);
}
private int ticket = 100;
@Override
public void run() {
while (true){
if(ticket > 0){
System.out.println(getName()+":卖票,票号为:"+ticket--);
}else {
break;
}
}
}
}
public class Test {
public static void main(String[] args) {
Window w1 = new Window("窗口一");
Window w2 = new Window("窗口二");
Window w3 = new Window("窗口三");
w1.start();
w2.start();
w3.start();
}
}
输出结果:
出现了同一张票,被多个窗口卖出的情况。这是因为我们提供的ticket是实例变量,属于每一个对象,每一个线程,这个资源不被共享。如果我们把ticket设为静态变量:
java private static int ticket = 100;
输出结果:
大致是共享了资源,但是还会出现一些问题!实际上这里就有线程安全问题。这里输出是因为要有一定延迟,所以从输出结果看并不是依次递减。
创建多线程
方法二:实现Runnable接口
1.创建一个实现了Runnable接口的类
2.实现Runnable类的抽象方法:run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器,创建Thread类的对象
5.通过Thread类对象调用start方法。
package com.xzc;
class MyThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class Test {
public static void main(String[] args) {
new Thread(new MyThread(),"线程一").start();
}
}
输出结果:
遍历了0~100的偶数,这里就是创建一个实现了runnable类接口的类的对象,把他作为参数传入Thread类的构造器,其实该构造器还可以有一个参数,就是线程名,我们这里直接用。这里的start有两个作用:1.启动线程。2.调用Runnable类型的target的run方法。我们可以重用这个类,再启动一个线程。
package com.xzc;
class MyThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2 == 0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class Test {
public static void main(String[] args) {
new Thread(new MyThread(),"线程一").start();
new Thread(new MyThread(),"线程二").start();
}
}
输出结果:
再谈卖票问题
package com.xzc;
class Window implements Runnable{
public Window(){}
private int ticket;
public Window(int ticket){
this.ticket = ticket;
}
@Override
public void run() {
while (true){
if(ticket > 0){
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket--);
}else {
break;
}
}
}
}
public class Test {
public static void main(String[] args) {
Window w = new Window(100);
new Thread(w,"窗口一").start();
new Thread(w,"窗口二").start();
new Thread(w,"窗口三").start();
}
}
输出结果:
可以发现,已经能比较好地实现资源共享了,但是这种实现方式也有线程安全问题,也会有重票的问题。但是,我们没有加static关键字,就有100张票,这是因为虽然ticket是实例变量,但是我们只有一个window对象放到构造器当参数,自然而然就是同一个ticket。
两种创建多线程方式
开发中,优先选择实现Runnable接口的方式,原因:
1.实现的方式没有类的单继承的局限性,可以让类继承一些特定的父类。
2.实现的方式更适合来处理多个线程共享数据的情况。
联系:Thread本身就实现了Runnable接口。
相同点:两种方式都要重写run方法。
线程的生命周期
线程安全
如果我们让实现runnable接口的车票程序的run方法里加个sleep
package com.xzc;
class Window implements Runnable{
public Window(){}
private int ticket;
public Window(int ticket){
this.ticket = ticket;
}
@Override
public void run() {
while (true){
if(ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"卖票,票号为:"+ticket--);
}else {
break;
}
}
}
}
public class Test {
public static void main(String[] args) {
Window w = new Window(100);
new Thread(w,"窗口一").start();
new Thread(w,"窗口二").start();
new Thread(w,"窗口三").start();
}
}
输出结果:
输出0和-1的概率大大提升。这是因为有一张票的时候,我们t1线程进来,被阻塞,还没输出,t2进来,也被阻塞,同理t3,然后就出现了如下情况:
不管是重票还是错票,问题出现的原因都是当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。如何解决?当一个线程在操作ticket的时候,其他线程不能参与进来,直到该线程完成操作。这种情况,即使该线程被阻塞,也不能被改变。
同步代码块解决实现Runnable接口的线程安全问题
关键字:synchronized
synchronized(/*同步监视器*/){
//需要被同步的代码
}
//操作共享数据的代码,即为需要被同步的代码
//同步监视器,俗称锁。任何一个类的对象,都可以充当锁。要求多个线程,共用同一把锁。
package com.xzc;
class Window implements Runnable{
public Window(){}
private int ticket;
public Window(int ticket){
this.ticket = ticket;
}
Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket--);
} else {
break;
}
}
}
}
}
public class Test {
public static void main(String[] args) {
Window w = new Window(100);
new Thread(w,"窗口一").start();
new Thread(w,"窗口二").start();
new Thread(w,"窗口三").start();
}
}
输出结果:
一定注意要求多个线程,共用同一把锁,这里我们一个window对象,就一个对象obj,保证了所有线程共用一个锁。不会出现线程安全问题。
同步的好处时解决了线程安全问题,但是操作同步代码时,只能有一个线程参与,其他线程等待,相当于一个单线程过程,效率比较低。
同步代码块解决实现继承Thread类的线程安全问题
因为此时是不一样的window对象,如果和之前用一样的方法,肯定不能共用一个锁,因为每一个window对象的obj实例不一样,导致无法共用一个锁。把obj设为static即可。
package com.xzc;
class Window2 extends Thread{
public Window2(){
}
public Window2(String name){
super(name);
}
private static int ticket = 100;
private static final Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":卖票,票号为:" + ticket--);
} else {
break;
}
}
}
}
}
public class Test2 {
public static void main(String[] args) {
Window2 w1 = new Window2("窗口一");
Window2 w2 = new Window2("窗口二");
Window2 w3 = new Window2("窗口三");
w1.start();
w2.start();
w3.start();
}
}
输出结果:
在实现Runnable接口的锁,其实直接用this关键字即可。synchronized (this){}
,因为这里this指的是Window的一个对象,他是实现Runnable接口的类的对象,唯一,所以为了方便,不用new一个object,直接用this即可。但是在继承thread类的对象中,就不能用this了,因为我们new了三个对象出来,不是唯一的。有什么简便方法呢,用反射。
package com.xzc;
class Window2 extends Thread{
public Window2(){
}
public Window2(String name){
super(name);
}
private static int ticket = 100;
private static final Object obj = new Object();
@Override
public void run() {
while (true){
synchronized (Window2.class) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":卖票,票号为:" + ticket--);
} else {
break;
}
}
}
}
}
public class Test2 {
public static void main(String[] args) {
Window2 w1 = new Window2("窗口一");
Window2 w2 = new Window2("窗口二");
Window2 w3 = new Window2("窗口三");
w1.start();
w2.start();
w3.start();
}
}
我们在synchronized参数传入Window2的Class对象即可。synchronized (Window2.class)