1,什么是多线程
多线程顾名思义就是多个线程在程序中运行,就比如我们的虚拟机JVM,启动的时候不止启动一个线程,至少有一个是负责Java程序的执行还有一个是垃圾回收机制GC的线程。
一个进程中至少有一个线程
2,多线程的创建
一种是extend Thread类,另一种implement Runnable接口,大部分会使用implement Runnable接口,因为一个类只能继承一个父类,而实现可以实现多个接口,可扩展性比较好
//extend Thread类
public class ThreadDemo {
public static void main(String[] args) {
Demo demo = new Demo();
demo.start();
}
}
class Demo extends Thread{
@Override
public void run() {
for(int i=0 ; i<10; i++){
System.out.println("Demo.run() i = "+i);
}
}
}
//implement Runnable
public class ThreadDemo {
public static void main(String[] args) {
Demo demo = new Demo();
Thread thread1 = new Thread(demo);
Thread thread2 = new Thread(demo);
thread1.start();
thread2.start();
}
}
class Demo implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName()+" , sale ticket = "+ticket--);
}
}
}
}
运行结果部分,由于数据太多就贴这么多,可以看到线程1和线程2是交替进行打印:
Thread-0 , sale ticket = 100
Thread-1 , sale ticket = 99
Thread-0 , sale ticket = 98
Thread-1 , sale ticket = 97
Thread-0 , sale ticket = 96
Thread-1 , sale ticket = 95
Thread-1 , sale ticket = 93
Thread-1 , sale ticket = 92
Thread-1 , sale ticket = 91
Thread-1 , sale ticket = 90
Thread-1 , sale ticket = 89
Thread-1 , sale ticket = 88
Thread-1 , sale ticket = 87
Thread-1 , sale ticket = 86
Thread-1 , sale ticket = 85
.....
Thread-0 , sale ticket = 2
Thread-1 , sale ticket = 7
Thread-0 , sale ticket = 1
在多线程运行中,其实每一次的运行结果都是不同的,因为多个线程都获取CPU的执行权,CPU执行到谁,谁就运行,明确一点,在某一个时刻,只能有一个程序在运行(多核除外)
CPU在做着快速的切换,已达到看上去是同时运行的效果,我们可以形象把多线程的运行行为在互相抢夺CPU的执行权。
这就是多线程的一个特性:随机性,谁抢到谁执行,至于执行多长,CPU说的算
3,线程的运行状态
线程的运行状态如下图,包含这些方法 start(),sleep(),wait(),notify(),run()
4,多线程的同步
这里由于多线程存在安全问题,所以引出了同步这个概念
在上面的买票例子中我们加一个睡眠就会让线程变得不安全,会出现票为0,-1的情况,如下:
private int ticket = 100;
@Override
public void run() {
while (true) {
if (ticket > 0) {
//当ticket为1时,会出现一种情况就是第一个线程会这里睡一会,
//而第二个线程走进来时执行打印,ticket就会变为0,
//而第一个线程睡醒又会执行打印,ticket变为-1
try {
Thread.sleep(10);//线程睡眠
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" , sale ticket = "+ticket--);
}
}
}
部分打印结果,虽然结果没有包含-1,但是 是有这种情况出现的,可以看到0已经出现了:
....
Thread-0 , sale ticket = 3
Thread-0 , sale ticket = 2
Thread-1 , sale ticket = 1
Thread-0 , sale ticket = 0
如何解决出现的这个问题呢,就需要synchronized,这里会说三种情况的锁:
1,同步代码块锁object
2,同步函数锁this
3,静态同步函数锁class对象
经典理解锁的现实案例:火车上卫生间
同步的前提:
1,必须要有两个或者两个以上的线程
2,必须是多个线程使用同一个锁
必须保证同步中只能有一个线程在运行
好处:解决了多线程的安全问题
弊端:多个线程需要判断锁,较为消耗资源
1,同步代码块锁object,继续对上面的例子进行修改:
class Demo implements Runnable{
Object object = new Object();//定义一个锁对象,不管什么对象都可以
private int ticket = 100;
@Override
public void run() {
while (true) {
//同步代码块
synchronized (object) {//有了同步锁之后,线程1执行完之后,另一个线程2才可以执行
if (ticket > 0) {
try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+" , sale ticket = "+ticket--);
}
}
}
}
}
执行结果已经正常,没有0出现:
....
Thread-1 , sale ticket = 10
Thread-1 , sale ticket = 9
Thread-1 , sale ticket = 8
Thread-1 , sale ticket = 7
Thread-1 , sale ticket = 6
Thread-1 , sale ticket = 5
Thread-1 , sale ticket = 4
Thread-1 , sale ticket = 3
Thread-1 , sale ticket = 2
Thread-1 , sale ticket = 1
2,同步函数锁this
同步函数用的是哪一个锁呢?函数需要被对象调用,那么函数都有一个所属对象引用,就是this,所以同步班函数使用的锁就是this。
class Demo implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true) {
this.show();
}
}
private synchronized void show(){
if (ticket > 0) {
try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+" , sale ticket = "+ticket--);
}
}
案例:有两个储户,分别存储300,每次存储100
public class ThreadDemo {
public static void main(String[] args) {
Demo demo = new Demo();
Thread thread1 = new Thread(demo);
Thread thread2 = new Thread(demo);
thread1.start();
thread2.start();
}
}
class Demo implements Runnable{
private int ticket = 100;
Bank b = new Bank();
@Override
public void run() {
for (int x = 0; x < 3; x++) {
b.add(ticket);
}
}
class Bank{
private int sum ;//共享数据
public synchronized void add(int n){**//同步函数**
sum = sum+n;//可能出现不安全情况,当sum为100时,1线程执行,睡眠,线程2进来,sum也为100,线程2输出200,线程1醒来也输出200,出现问题。
try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println(sum);
}
}
}
加上锁之后,打印:
100
200
300
400
500
600
没加锁之前打印,可以看到出现了两次200,说明线程不安全执行了:
200
300
200
500
600
3,静态同步函数锁class对象
如果同步函数被静态修饰后,使用的锁是什么呢?通过验证,发现不在是this,因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象,类名.class,该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象,类名.class
下面代码出现了两个地方同步,一个是静态的同步,一个是同步的代码块用的锁是Class,但是他们都是同一个锁,所以运行结果也是安全的。
class Demo implements Runnable{
private static int ticket = 100;
Boolean flag = true;
@Override
public void run() {
if(flag){
while (true) {
synchronized (Demo.class) {//同步代码函数,锁对象时class
if (ticket > 0) {
try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+" , sale ticket = "+ticket--);
}
}
}
}else{
while (true) {
show()
}
}
}
private static synchronized void show(){//静态的同步函数
if (ticket > 0) {
try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}
System.out.println(Thread.currentThread().getName()+" , sale ticket = "+ticket--);
}
}
5,单例模式
1,饿汉式
class Single
{
private static final Single s = new Single();
private Single(){}
public static Single getInstance(){
return s;
}
}
2,懒汉式
下面的写法并不安全
class Single
{
private static Single s = null;
private Single(){}
private static Single getInstance()
{
if(s==null)
//---->A A线程睡醒new第一次
//---->B B线程也new第一次
s = new Single();
return s;
}
}
加上锁:
class Single
{
private static Single s = null;
private Single(){}
private static Single getInstance()
{
synchronized(Single.class)//静态方法需要使用静态锁
{
if(s==null)
s = new Single();
}
return s;
}
}
为了防止线程多次读锁,也可以再次优化:
class Single
{
private static Single s = null;
private Single(){}
private static Single getInstance()
{
//3. 待A醒来之后,s边不再为空,那么C,D...线程判断s不为空就不会在进去
if(s == null)
{
//2. B 在A睡眠的时候也可以进去,但是没有锁就不能进去
synchronized(Single.class)
{//4. A出去之后,B进来,但是s有值了,也进不去
if(s==null)
//1. ---->A进来,睡眠
s = new Single();
}
}
return s;
}
}
6,多线程的死锁
同步中的嵌套同步。
了解即可,定义了两个静态的对象
线程1拿了locka的锁,进入下一个同步需要lockb的锁,但是线程2拿了lockb的锁,进入下一个同步需要locka的锁,
线程1和线程2 都没有释放自己的锁,导致运行卡住
运行结果,都在等对方的锁,导致运行卡住: