1,多线程概念及相关对象
1.1多线程概念
(1)进程:是一个正在执行中的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径,或者叫一个控制单元
(2)线程:就是进程中的一个独立的控制单元,线程在控制着进程的执行。
(3)多线程,多个线程共同执行一段代码,已达到提高效率,比如,一个浏览器必须能同时下载多个图片;一个Web服务器必须能同时响应多个用户请求;等都需要使用多线程技术来完成。
java已经提供了对线程这类事物的描述。就是thread类。
1.2,多线程的优势
(1)进程之间不能共享内存,但是线程之间共享内存非常容易。
(2)系统创建进程时需要为该进程重新非配系统资源,但创建线程则代价小的多,因此使用多线程来实现多任务并发比多进程的效率高。
(3)java语言内置了多线程功能支持,而不是单纯地作为底层操作系统的调度方式,从而简化了java的多线程编程。
1.3计算机CPU的运行原理
当我们电脑上有很多的程序在运行时会让人感觉是同时进行,但是在一个时刻,单核的cpu只能运行一个程序。而我们看到的同时运行效果,只是cpu在多个进程间做着快速切换动作。
而cpu执行哪个程序,是毫无规律性的。这也是多线程的一个特性:随机性。哪个线程抢到了cpu的执行权,哪个线程就执行。而cpu不会一直执行这个程序到结束,而是执行一个一会后,又会去执行另一个,而调度的方法是由系统决定的。
1.4线程的创建
(1)创建线程的第一种方式:继承Thread类。
步骤:
1,定义类继承Thread类
2,复写Thread类中的run方法。
目的:将自定义的代码存储在run方法中,让线程运行。
3,调用线程的start方法,
该方法两个作用:启动线程,调用run方法。
问:为什么要覆盖run方法呢?
答:Thread类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。(Thread类里的run()方法的方法体是空的,所以想要执行自己指定的代码就得覆盖父类的run()方法)
实例:
class FirstThread extends Thread
{
public void run(){
for(int x=0;x<50;x++)
{
//当线程继承Thread类时,直接使用this即可获得当前线程
//Thread对象的getName()返回当前线程的名字
System.out.println(getName()+".."+i);
//System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
}
class ThreadDemo
{
FirstThread tf = new FirstThread();//创建好一个线程。
ft.start();//开启线程,并执行该线程的run方法。
for(int x=0;x<50;x++)
{
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
(2)创建线程的第二种方式:实现Runable接口
步骤:
1,定义类实现Runnable接口
2,覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
3,通过Thread类建立线程对象。
4,将Runnable接口中的子类对象作为实际参数传递给Thread类的构造函数。
问:为什么要将Runnable接口的子类对象传递给Thread的构造函数
答:因为自定义的run方法所属的对象是Runnable接口的子类对象。
所以要让线程去执行指定对象的run方法。就必须明确该run方法所属的对象。
5,调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
实例:
class RunnableThread implements Runnable
{
public void run(){
for(int x=0;x<50;x++)
{
//当线程实现Runnable接口时
//如果想要获取当前线程,只能用Thread.currentThread()
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
}
class ThreadDemo
{
RunnableThread rt = new RunnableThread();
//下面两个线程共用rt这个资源
new Thread(rt).start();
new Thread(rt).start();//开启线程,并执行该线程的run方法。
for(int x=0;x<50;x++)
{
System.out.println(Thread.currentThread().getName()+"..."+i);
}
}
(3) 两种方式的对比:
1,采用实现Runnable接口的方式创建多线程
->线程类只是实现了Runnable接口,还可以继承其他类。
->在这种方式下,多个线程共享一个Runnable子类对象,所以非常适合多个相同线程来吹同一份资源的情况。
->劣势是:如果需要访问当前线程,则必须使用Thread.currentThread()方法。
2,采用继承Thread类的方式
->因为线程类已经继承了Thread类,所以不能再继承其他类父类。
->如果需要访问当前线程,则无需使用Thread.currentThread()方法,直接使用this即可获得当前线程。
1.5线程运行状态
被创建:等待启动,调用start启动。
运行状态:具有执行资格和执行权。
阻塞状态:有执行资格,但是没有执行权(没有处理器资源)。
冻结状态:遇到sleep(time)方法和wait()方法时,失去执行资格和执行权,sleep方法时间到或者调用notify()方法时,获得执行资格,变为阻塞状态。
消忙状态:stop()方法,或者run方法结束。
2,线程同步
2.1线程安全问题
2.1.1引发安全问题的原因
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分还没有执行完,
另一个线程参与进来执行。导致了共享数据的错误。
2.2线程同步问题
2.2.1,同步代码块
JAVA对于多线程的安全问题提供了专业的解决方式。
1,同步代码块。
synchronized(obj)
{
需要被同步的代码。//哪些代码需要同步?看哪些语句在操作共享数据。
}
2)obj(对象)如同锁(监视器)
持有锁的线程可以在同步中执行。没有持有锁的线程即使夺取了cpu的执行权,也进不去。因为没有获取锁
3)obj(对象)的选定
虽然java程序允许使用任何对象作为同步监视器,但想一下同步监视器的目的:阻止两个线程对同一个共享资源进行并发访问,
因此通常使用可能被并发访问的共享资源充当同步监视器。
4)好处和弊端
好处:解决多线程的安全问题。
弊端:多个线程都需要判断锁,较为消耗资源。
2.2.2,同步函数
与同步代码块对应,java的多线程安全支持还提供了同步方法,同步方法就是使用synchronized关键字来修饰某个方法,则该方法称为同步方法。
对于同步方法而言,无须显式指定同步监视器,同步方法的同步监视器是this,也就是该对象本身。
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。类名.class
2.2.3,同步的前提
1,必须有两个或者两个以上的线程。(两个人以上才锁门)
2,必须是多个线程使用同一个锁。
如果加了同步还出现安全问题就要考虑到两个前提是否都满足。
2.2.4,如何寻找多线程中的安全问题
1,明确哪些代码是多线程运行代码。
2,明确共享数据。
3,明确多线程运行代码中哪些语句是操作共享数据的。
2.2.5,利用同步的知识实现单例模式的懒汉式
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}
return s;
}
}
2.3,死锁
2.3.1原理:
一个同步里面嵌套一个同步,锁不一样。
2.3.2说明:
有两个程序,A持有一个锁,B也持有一个锁,A要到B里面去运行,要拿到B的锁,而B要到A里面运行,也要拿到A的锁
互相不释放自己的锁,又得要进到对方程序里运行就产生了死锁2.3.3死锁例子:
class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
synchronized(MyLock.locka)
{
System.out.println("if locka");
synchronized(MyLock.lockb)
{
System.out.println("if lockb");
}
}
}
else
{
synchronized(MyLock.lockb)
{
System.out.println("else lockb");
synchronized(MyLock.locka)
{
System.out.println("else locka");
}
}
}
}
}
class MyLock
{
static Object locka = new Object();
static Object lockb = new Object();
}
class DeadLockTest
{
public static void main(String[] args)
{
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
2.4线程通信
2.4.1,方法
1,wait()
导致当前线程等待,直到其他线程调用该不同监视器的notify()或notifyAll()方法来唤醒该线程。
调用wait()方法的当前线程会释放对该同步监视器的锁。
2,notify()
唤醒在此同步监视器上等待的单个线程。
3,notifyAll()
唤醒在此同步监视器上等待的所有线程。
当多个线程进行存,多个进行进行取时,避免程序最后被阻塞无法继续向下执行。可以使用notifyAll()
但是notifyAll()方法是将所有等待线程唤醒,可不可只唤醒对方线程呢?
2.4.2,思考
1,问:为什么这些操作线程的方法要定义在Object的类中呢?
答:因为这3个方法需要同步监视器对象来调用,而同步监视器对象可以是任意对象。
2,问:wait()和sleep()有什么区别。
答:wait():释放资源,释放锁;sleep():释放资源,不释放锁。
2.4.3,多个线程在操作同一个资源,(一个线程在存,一个线程在取),
为了实现这个功能,可以借助于Object类提供的wait(),notify()和notifyAll()3个方法,这3个方法并不属于Thread类,而是属于Object类,但是这三个方法必须由同步监视器对象来调用。
实例:
class Res
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){}
this.name = name;
this.sex = sex;
flag = true;
this.notify();
}
public synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception e){}
System.out.println(name+"...."+sex);
flag = false;
this.notify();
}
}
class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
if(x==0)
r.set("mike","man");
else
r.set("丽丽","女女");
x = (x+1)%2;//切换
}
}
}
class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}
class InputOutputDemo2
{
public static void main(String[] args)
{
Res r =new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}
2.4.4,多个线程在操作同一个资源,(多个线程在生产,多个线程在消费)
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;//资源空间必须都有标记。
public synchronized void set(String name)
{
while(flag)//if(flag) 可能t2复活时没有判断标记,所以用while循环
try{wait();}catch(Exception e){}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
flag = true;
this.notifyAll();//用的是全部唤醒 ,能不能只唤醒对方。
}
public synchronized void out()
{
while(!flag)//if(!flag)
try{wait();}catch(Exception e){}
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("+商品+");
}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}
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(con);
t1.start();
t2.start();
}
}
3,Lock类与Condition类
3.1Lock类
将同步Synchronized(隐视加锁,解锁) 替换成实现Lock操作(显示加锁,解锁)
( Lock实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操作)
lock():获取锁。
unLock()释放锁。
3.2Condition类
如果程序不使用synchronized关键字来保证同步,而是直接使用Lock对象来保证同步,则系统不存在隐式的同步监视器,也就不能使用wait(),notify(),notifyAll()方法进行线程通信。
所以在使用Lock对象时,java提供了一个Condition类来保持协调。
Condition实例被绑定在一个Lock对象上,要获得特定Lock实例的Condition实例,调用Lock对象的newCondition()方法即可,
Condition替代了同步监视器的功能。Condition提供了3个方法await(),signal(),aignalAll()来替换wait()wait(),notify(),notifyAll().
具体使用方法:
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
4,多线程其他方法
4.1,停止线程
stop方法已经过时。
suspend:会发生死锁
问:如何停止线程?
答:只有一种,run方法结束。开启多线程运行,运行代码通常都是循环结构。
只要控制循环,就可以让run方法结束,也就是线程结束。
但是,当线程处于冻结作态,就不会读取到标记,那么线程就不会结束。
所以,当没有指定的方式让冻结的线程回复到运行状态时,这时需要对冻结进行清除,强制让线程恢复到运行状态中来,这样可以操作标记让线程结束。
Thread类提供该方法 interrupt();会产生InterruptedException.
步骤:
1,定义循环结束标记
因为线程运行代码一般都是循环,只要控制了循环即可。
2,使用interrupt(中断)方法(不正常唤醒,会发生异常)
该方法是结束线程的冻结状态(wait,sleep),使线程回到运行状态中来
4.2,后台线程
1)有一种线程,它是在后台运行的,它的任务是为其他的线程提供服务,这种线程被称为“后台线程”,又称为守护线程。JVM的垃圾回收线程就是典型的后台线程。
2)后台线程有一个特性:如果所有的前台线程都死亡,后台线程会自动死亡。
3)调用Thread对象的setDaemon(true)方法可将指定线程设置成后台线程。
4)setDaemon(true)必须在start()方法之前调用,否则会引发illegalThreadStateException异常。
4.3,join线程
Thread提供了让一个线程等待另一个线程完成的方法--join()方法。当在某个程序执行流中调用其他线程的join()方法时,调用线程将被阻塞,直到被join方法加入的join线程执行完为止。
用法:join()方法通常由使用线程的程序调用,以将大问题划分成许多小问题,每一个小问题分配一个线程。当所有的小问题都得到处理后,再调用主线程来进一步操作。
4.4,线程让步:yield
yield()方法是一个和sleep()方法有点相似的方法,它也是Thread类提供的一个静态方法,它也可以让当前正在执行的线程暂停,但他不会阻塞该线程,它只是将该线程转入就绪状态。
yield()只是让当前的线程暂停一下,让系统的线程调度器重新调度一次,完全可能的情况是:当某个线程调用了yield()方法暂停之后,线程调度器又将其调度出来重新执行。
5,改变线程优先级
Thread提供了setPriority()方法来设置指定线程的优先级,其中参数可以是一个整数,1-10.也可以使用Thread类的如下3个静态常量。
->MAX_PRIORITY 10
->MIN_PRIORITY 1
->NORM_PRIORITY 5