Java基础 线程入门

Java基础 线程

线程的概述

进程 正在运行的程序 负责这个程序的内存空间分配 代表内存中的执行区域

线程 就是在一个进程中负责一个执行路径

多线程 就是在一个进程中多个路径同时执行(例如杀毒软件同时在做系统优化和垃圾清理)

自定义线程方式（一）

一种方式是将该类声明为Thread子类

(1) 该子类重写Thread的run方法 将自定义线程的任务代码放到run方法中

(2) 创建自定义线程对象 调用start方法 线程开启后调用到run方法

（不能直接调用run方法 只有调用start方法才算开启一个线程）

public class Demo extends Thread {
	@Override
	public void run() {
		for(int i=0;i<100;i++) {
			System.out.println("自定义线程"+i);
		}
	}
	public static void main(String[] args) {
		Demo d=new Demo();
		d.start();
		for(int i=0;i<100;i++) {
			System.out.println("main线程"+i);
		}
	}
}

结果可以看到交替出现

自定义线程方式（二）

自定义一个类去实现Runnable接口

（1）自定义一个类实现Runnable接口

（2）实现Runnable接口的run方法 把自定义线程的任务代码定义在run方法上

（3）创建Runnable实现类对象

（4）创建Thread对象 把Runnable实现类对象作为参数传入

（5）调用Thread的start方法开启线程

public class Demo implements Runnable {
	public static void main(String[] args) {
		Demo d=new Demo();
		Thread t=new Thread(d,"Mythread");
		t.start();
		for(int i=0;i<100;i++) {
			System.out.println("main线程"+i);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
	}
}

同样的我们看到结果的交替出现

这是我们来看一个问题 为什么要把Runnable实现类对象作为参数传递进去呢？

我们看两段Thread源码中的操作

//这个构造方法中 用target变量记录了Runnable实现类对象
public Thread(Runnable target, String name) {
        init(null, target, name, 0);
    }

/*这个是Thread类的run方法 可以看到在Thread的run方法中 又调用了
tatget的run方法 这个run方法就是我们自己重写的run方法*/
public void run() {
        if (target != null) {
            target.run();
        }
    }

这样我们在加深一下理解

public class Demo implements Runnable {
	public static void main(String[] args) {
		Demo d=new Demo();
		Thread t=new Thread(d,"Mythread");
		t.start();
		for(int i=0;i<100;i++) {
			System.out.println("main线程"+i);
		}
	}

	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<100;i++) {
			System.out.println(Thread.currentThread().getName()+" "+i);
		}
		System.out.println(Thread.currentThread());//当前线程对象 t
		System.out.println(this);//该函数的调用者对象 d
	}
}

this关键字指的是该函数的调用者对象 这个run方法目前是由target在调用 而恰恰target就是记录的Runnable实现类的对象 也就是d对象

线程生命周期

(害 本来想自己画图来 可是这个图太漂亮了 就直接拿过来了)

线程安全问题

我们来模拟一个线程安全问题

现在有这样一个需求 3个窗口要卖50张票 我们将3个窗口看做3个线程 来模拟实现这个问题

class TicketSales extends Thread{
	static int num=50;
	public  TicketSales(String name) {
		super(name);
	}
	@Override
	public void run() {
		while(true) {
			if(num>0) {
				System.out.println(Thread.currentThread().getName()+"卖出了"+num+"号票");
				num--;
			}else {
				System.out.println("售完了");
				break;
			}
		}
	}
}
public class Demo {
	public static void main(String[] args) {
		TicketSales thread1=new TicketSales("窗口1");
		TicketSales thread2=new TicketSales("窗口2");
		TicketSales thread3=new TicketSales("窗口3");
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

这时候的结果 我们来看 出现了线程安全问题 50号票被卖了3次

我们来分析一下这个原因 可能的情况是当thread1刚刚执行到买票这句话是 还没来得及做num–时 这时候的cpu执行权被thread3 抢走了 同样的当thread3执行到买票这句话时 cpu的执行权又被thread2抢走了 这就造成了50号票被卖了3次的情况

同步代码块解决线程安全问题

class TicketSales extends Thread{
	static int num=50;
    //锁对象必须是多个线程共享的对象 否则没有意义 用static修饰
	static Object o=new Object();
	public  TicketSales(String name) {
		super(name);
	}
	@Override
	public void run() {
		while(true) {
			synchronized (o) {//o是多个线程共享的锁对象
				if(num>0) {
					System.out.println(Thread.currentThread().getName()+"卖出了"+num+"号票");
					num--;
				}else {
					System.out.println("售完了");
					break;
				}
			}
		}
	}
}
public class Demo {
	public static void main(String[] args) {
		TicketSales thread1=new TicketSales("窗口1");
		TicketSales thread2=new TicketSales("窗口2");
		TicketSales thread3=new TicketSales("窗口3");
		thread1.start();
		thread2.start();
		thread3.start();
	}
}

这时 利用同步代码块解决了线程安全问题