Java基础篇之多线程
进程:是一个正在执行的应用程序。
每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。
线程在控制着进程的执行。
一个进程中至少有一个线程。
Java VM启动的时候会有一个进程java.exe
该进程中至少一个线程负责java程序的执行,而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展:其实JVM启动不止一个线程,还有负责垃圾回收机制的线程。
如何在一个自定义的代码中自定义一个线程呢?
通过对Java API的查找,Java已经提供了对线程这类事物的描述,Thread类,Runable接口。
创建新执行线程有两种方法:
一种方法是继承Thread类。
步骤:
1、 定义类继承Thread。
2、 复写Thread类的run方法。
目的:将自定义代码存储在run方法中,让线程运行。
3、 创建对象,调用线程的start方法。
该方法两个作用:启动线程,调用run方法。
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序运行。(多核除外)
cpu在做着快速切换,以达到看上去是同时运行的效果。
我们可以形象地把多线程的运行行为看做是在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长时间,cpu说的算。
为什么要覆盖run方法呢?
Thread类用于描述线程。
该类就定义一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
线程的生命周期:
获取线程名称的方法:
1.super(name)获取父类中setName的方法
2.当前类中this.getName()获取name;
3.Thread.currentThread.getName()获取当前执行线程的名称,常用这个方法。
创建线程的第二种方式:实现Runnable接口
步骤:
1、 定义类实现Runnable接口;
2、 覆盖Runnable接口中的run方法;
将线程要运行的r代码存放在该run方法中。
3、 通过Thread类建立线程对象;
4、 将Runnable接口的子类对象作为实际参数传递给Thread类的构造方法;
为什么要将Runnable接口的子类对象传递给Thread的构造方法?
因为,自定义的run方法所属对象是Runnable接口的子类对象
所以要让线程去执行指定对象的run方法,就必须明确该run方法所属对象。
5、 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实现方式和继承方式有什么区别呢?
假如有一个类与另一个类有共性,向上抽取,形成了父类,但是需要用多线程执行,其就不能继承Thread方法,这样就出现了Runnable接口让其实现,用多实现的方法解决单继承的问题。
实现方式的好处:避免了单继承的局限性。
在定义线程时,建议使用。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable:线程代码存放在接口子类的run方法中。
多线程运行出现安全问题。
问题原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没执行完,另一个线程参与进来执行,导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可参与。
Java对于多线程的安全问题提供了专业的解决方式,同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁,持有锁的线程可以再同步中执行。
没有持有锁的线程即使获取了cpu的执行权,也进不去,因为没有获取锁。
如同火车上的卫生间。
同步的前提:
1. 必须要是两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁。
3. 必须保证同步中只能有一个线程在运行。
好处:解决了多线程安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
如何判断一个程序是否有安全问题?
1、 明确哪些代码是多线程的运行代码;
2、 明确共享数据;
3、 明确多线程运行代码中哪些语句是操作共享数据的。
除了同步代码块外,还可有在方法前加synchronized,使之成为同步方法,同步方法中的代码。
同步方法用的是哪一个锁呢?
方法需要被对象调用,那么方法都有一个所属对象的引用,就是this。
所以同步方法使用的锁是this。
静态同步方法用的是哪一个锁呢?
静态同步方法是类方法,直接被类名调用,那么它的锁就是类的字节码文件对象。
所以静态同步方法使用的锁是<类名>.class
多线程-单例设计模式-懒汉式
饿汉式
classSingle
{
private static final Single s = newSingle();
private Single ()
{
}
public static Single getInstance()
{
returns;
}
}
懒汉式
classSingle
{
private static Single s = null;
private Single ()
{
}
public static Single getInstance()
{
if(s==null)//为了避免重复读锁,减少读锁次数。
{
synchronized (Single.class)
{
If(s==null)
s= new Single();
returns;
}
}
}
}
懒汉式:特点在于实例延时加载,多线程访问会出现安全问题,用双重判断的同步代码块进行同步,可解决安全问题,同时减少了不必要的读锁,节省资源。使用的锁是该类所属的字节码文件对象
死锁:两个线程都想到彼此的同步代码块内运行,但是彼此都不放锁,还都在继续要,一直要,就出现了死锁。
同步中嵌套同步,而锁不同。
写一个死锁程序:
线程间通讯:
其实就是多个线程在操作同一个资源,但是操作动作不同。
等待唤醒机制
wait();
notify();
notifyAll();
都使用在同步中,因为要对持有锁的线程操作,
只有同步才有锁。
为什么这些操作线程的方法要定义在object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作的线程持有的锁,
只有同一个锁上的等待线程可以被同一个锁上的notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义在object类中。
为什么要定义notifyAll()?
因为需要唤醒对方线程。
因为只用notify,容易出现只唤醒本方线程的情况,导致程序中所有程序都wait。
JDK1.5中提供了多线程升级方案。
将同步synchronized替换成lock操作。
将object中的wait,notify,notifyAll,替换成Condition对象。
该对象可以lock锁进行获取。
停止线程
如何停止线程?
只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。
只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:
当线程处于冻结状态,就不会读取循环结束标记,那么线程就不会结束。
当没有指定方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除。
此时使用interupt方法
该方法是结束线程的冻结状态,使线程回到运行状态中来,读取循环结束标记。
注:stop方法已经过时,不再使用了。
守护线程:
假如此时main线程中还有t1和t2线程,
我们对t1和t2线程使用t1.setDaemon(true)he t2.setDaemon(true),
那么这时t1和t2就变为main的守护线程。
当main线程结束,作为main的守护线程,t1和t2也跟着结束了。
Join方法:
要抛出InteruptedException
假如,现在main方法里有3个线程,分别为main,t1和t2。
main线程碰到t1线程的join,main线程交出cpu执行权给t1,自己处于冻结状态
t1得到执行权要么自己一个人玩,要么就跟t2线程一起玩(看join的位置)
等到自己玩完了,才会释放cpu执行权,
main线程才能得到cpu的执行权继续玩。
该方法常用于临时加一个线程运行。
多线程的优先级&yield方法
多线程中一共有10个优先级,
用setPriority()方法设置优先级,为了提高阅读性,一般不写数字。
而是使用
Thread.MAX_PRIORITY 优先级是10
Thread.MIN_PRIORITY 优先级是1
Thread.NORM_PRIORITY优先级是5
Yield()方法:
临时停止线程,强制让线程交出cpu执行权,有机会让线程平均使用cpu。
验证同锁:
class LockDemo
{
public static void main(String[] args)
{
User u = new User(1);
Thread t1 = new Thread(u);
Thread t2 = new Thread(u);
t1.start();
try
{
Thread.sleep(10);throw InterruptedException;
}
catch (Exception e)
{
}
u.flag = false;
t2.start();
}
}
class User implements Runnable
{
private int count = 100;
private int computer ;
boolean flag = true ;
public User(int computer)
{
this.computer = computer ;
}
public void run()
{
if(flag)
{
while(true)
{
//synchronized(User.class)
synchronized(this)
{
if(count>0)
{
try
{
Thread.sleep(10);
}
catch (Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"..."+computer+"..."+count);
computer++;
count--;
}
}
}
}
else
while(true)
{
show();
}
}
public synchronized void show()
{
if(count>0)
{
try
{
Thread.sleep(10);
}
catch (Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"..."+computer+"......"+count);
computer++;
count--;
}
}
}
死锁练习:
class AlwaysLockDemo
{
public static void main(String[] args)
{
User u=new User();
Thread t1 = new Thread(u);
Thread t2 = new Thread(u);
t1.start();
try
{
Thread.sleep(10);
}
catch (InterruptedException e)
{
}
u.flag = false;
t2.start();
}
}
class User implements Runnable
{
private int computer = 100;
private int code = 1;
boolean flag = true ;
public void run()
{
if (flag)
{
while (true)
{
synchronized(User.class)
{
show();
}
}
}
else
while (true)
show();
}
public synchronized void show()
{
synchronized(User.class)
{
if (computer>0)
{
try
{
Thread.sleep(10);
}
catch (InterruptedException e)
{
}
System.out.println(Thread.currentThread().getName()+"---"+computer+"---"+code);
computer--;
code++;
}
}
}
}
线程间通信:等待唤醒机制练习
eg.
import java.util.concurrent.locks.*;
class LockConditionDemo
{
public static void main(String[] args)
{
Commander c = new Commander();
SoldierA a = new SoldierA(c);
SoldierB b = new SoldierB(c);
Thread t1 = new Thread(a);
Thread t2 = new Thread(a);
Thread t3 = new Thread(b);
Thread t4 = new Thread(b);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Commander
{
String name ;
int day = 1;
boolean flag = false ;
Lock lock = new ReentrantLock();
Condition A = lock.newCondition();
Condition B = lock.newCondition();
public void Awork(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
A.await();
this.name = name+"---"+day++;
System.out.println(Thread.currentThread().getName()+"--上半夜站岗--"+this.name);
flag = true ;
B.signal();
}
finally
{
lock.unlock();
}
}
public void Bwork(String name)throws InterruptedException
{
lock.lock();
try
{
while(!flag)
B.await();
this.name = name+"---"+day++;
System.out.println(Thread.currentThread().getName()+"------下半夜站岗------"+this.name);
flag = false;
A.signal();
}
finally
{
lock.unlock();
}
}
}
class SoldierA implements Runnable
{
private Commander com;
SoldierA(Commander com)
{
this.com = com ;
}
public void run()
{
while (true)
{
try
{
com.Awork("小强");
}
catch (InterruptedException e)
{
}
}
}
}
class SoldierB implements Runnable
{
private Commander com;
SoldierB(Commander com)
{
this.com = com ;
}
public void run()
{
while (true)
{
try
{
com.Bwork("大黄");
}
catch (InterruptedException e)
{
}
}
}
}
Interrupt方法应用:
eg.
class InterruptedDemo
{
public static void main(String[] args)
{
Stone s = new Stone();
Thread t1=new Thread(s);
Thread t2=new Thread(s);
t1.start();
t2.start();
int num = 0;
while (true)
{
if (num++==60)
{
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"---"+num);
}
System.out.println("over");
}
}
class Stone implements Runnable
{
private boolean flag = true;
public synchronized void run()
{
while (flag)
{
try
{
wait();
}
catch (InterruptedException e)
{
System.out.println(Thread.currentThread().getName()+"---InterruptedException");
changeFlag();
}
System.out.println(Thread.currentThread().getName()+"------run");
}
}
public void changeFlag()
{
flag=false;
}
}