多线程
多线程
a.进程
b.线程(例:FlashGet)
c.多线程存在的意义
d.线程的创建方式
e.多线程的特性
进程:是一个正在执行中的程序。
每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元。
线程:就是进程中的一个独立的控制单元。线程在控制着进程的执行。
一个进程中至少有一个线程。
Java VM启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展:其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回收机制的线程。
1.如何在自定义的代码中,自定义一个线程?
通过对api的查找,java已经提供了对线程这类事物的描述,就Thread类。
创建线程的第一种方式:继承Thread类。
步骤:
1.定义类继承Thread。
2.复写Thread类中的run方法。
目的:将自定义代码存储在run方法,让线程运行。
3.调用线程的start方法。
该方法两个作用:启动线程,调用run方法。
代码体现:
public class ThreadDemo extends Thread
{
public void run()
{
//代码实现
for(int x=0; x<100; x++)
{
System.out.println(getName()+"***"+x);
}
}
}
例:
classTest extends Thread
{
privateString name;
Test(Stringname)
{
this.name=name;
}
publicvoid run()
{
for(intx=0;x<60;x++)
{
System.out.println(name+"run..."+x);
}
}
}
class ThreadTest
{
publicstatic void main(String[] args)
{
Testt1=new Test("one");
Testt2=new Test("two");
t1.start();
t2.start();
// t1.run();
// t2.run();
}
}
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权,cpu执行到谁,谁就运行。
明确一点,在某一个时刻,只能有一个程序在运行。(多核除外)
cpu在做着快速的切换,以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说了算。
为什么要覆盖run方法?
Thread类用于描述线程。该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储线程要运行的代码。
线程运行状态
1.线程的生命周期包含状态:
新状态、就绪状态、阻塞状态、死亡状态
2.新状态
使用new刚刚创建完的Thread类的对象,还没有调用start()之前就是新状态!
3.就绪状态(可运行状态)
通过new a start() a就绪
通过阻塞a完成了阻塞a就绪
当调用了Thread对象的start()方法之后,这个线程就进入了就绪状态,或者我们称之为可运行状态。
当同时把100个线程都start()了,问:在某一个时间点上几个线程在运行?答案是一个,那么其他99个是什么状态啊?就绪状态。
4.运行状态
只能就绪状态才能到运行状态。
需要在就绪状态之后,由调度来分配运行时间片。
5.阻塞状态
线程运行一段时间后,应该休眠。这样可以给其他线程运行的机会!但有时间片来控制,也不会把程序搞的太卡了。
一般线程都会没有用完时间片就休眠了。
休眠:当线程执行了Thread.sleep()时,那么主进入了休眠状态!当线程经过了指定的休眠毫秒时,就回到了就绪状态!
等待:当线程执行了wait()方法,那么这个线程就晕过去了。只能等待其他线程调用notfiy()来唤醒(回到就绪)!这个东西,现在不研究!
挂起:t.suspend()这个线程就挂起了,只能等待其他线程调用resume()方法才能回到就绪状态。这两个方法都过时了,你不能去用它!
IO阻塞:当线程试图完成IO操作时,那么这个线程就进入了IO阻塞状态。只有完成了这个IO操作,才能回到就绪状态。
锁定:当线程试图使用一个被另一线程占用资源时,这个线程就被锁定了。只有另一线程用完了这个资源,那么线程才能使用这个资源。
当A线程需要使用资源o时,但现在o正在被B线程使用,这时A线程锁定了。直到B线程用完了o,然后A就回到了就绪状态。也就是说,A线程得不到o,它就不走了。
6.死亡状态
当任务完成后,它就自然死亡。
线程也能被枪毙了!调用Thread的stop()方法就是枪毙它,但stop()被作废了,不要用。
当抛出了一个异常使run()方法异常返回时,线程也就是意外死亡!run()方法没有声明异常,这说明能让线程的run()方法返回的异常只能是RuntimeException。
创建线程方式一:
继承thread类
1.子类覆盖父类中的run方法,将线程运行的代码存放在run中。
2.建立子类对象的同时线程也被创建。
3.通过调用start方法开启线程。
线程的四种状态图:
线程运行状态图:
获取线程对象以及名称
创建两个线程,和主线程交替运行。
原来线程都有自己默认的名称。
Thread-编号该编号从0开始。
static Thread.currentThread():获取当前线程对象。
getName():获取线程名称。
设置线程名称:setName或者构造函数。
start方法和run方法的区别:
start是开启线程并执行线程的run方法。
run仅仅是调用,线程创建了并没有运行。
wait()等待, notify()唤醒 等待执行后必须通过notify()进行唤醒。
currentThread()是获取当前对象,是静态的方法是可以通过类名进行调用的。
两个Thread类中的方法:
getName:获取线程的名称。
setName:设置线程的名称。
illegalThreadStateException:无效的线程异常。
如果想是线程必须是继承Thread或者是继承Thread的子类。
在创建线程对象的时候就要明确要使用那段代码,因为要使用的代码必须的放在run方法中。也就是放在复写了Thread类的子类中的run方法中。
创建线程方式二:实现Runnable接口
步骤:
(1)定义类实现Runnable接口
(2)覆盖Runnable接口中的run方法。
将线程要运行的代码存放在该run方法中。
(3)通过Thread类建立线程对象。
(4)将Runnable接口的子类对象作为实际参数进行传递给Thread类的构造函数。
为什么要将Runnable接口的子类对象传递给Thread的构造函数。
因为,自定义的run方法所属的对象是runnable接口的子类对象,所以要让线程去调用指定对象的run方法,就必须明确run方法所属的对象。
(5)调用Thread类的start方法开启线程并调用Runnable接口子类中的run方法。
实现方式(Runnable接口)和继承方式(Thread类)有什么区别?
实现方式好处:避免了java中单继承的局限性,在定义线程的时候建议使用实现方式(Runnable接口)。
存放的位置不一样:
继承是存放在Thread类的子类中,而实现是存放在Runnable的子类中。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
多线程的安全问题
多线程的运行出现了安全问题。
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized块的语法格式:
synchronized(对象)
{
需要被同步的代码
}
多线程同步代码块
对象如同锁,持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
例如:火车上的卫生间———经典。
同步的前提:
1. 必须要有两个或者两个以上的线程。
2. 必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
多线程—同步函数的锁是this
同步函数用的是哪一个锁?
函数需要被对象调用,那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
通过该程序进行验证。
使用两个线程来买票。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行买票动作。
例:
同步代码块:
Object obj=new Object();
While(true)
{
synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exceptione){}
System.out.println(Thread.currentThread().getName()+”…code:”+tick--);
}
}
}
同步函数:
public synchronized void show() //this
{
If(tick>0)
{
try{Thread.sleep(10);}catch(Exceptione){}
System.out.println(Thread.currentThread().getName()+”…show…:”+tick--);
}
}
多线程—静态同步函数的锁是class对象
如果同步函数被静态修饰后,使用的锁是什么?
通过验证,后发现不再是this。因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
多线程-单例设计模式-懒汉式
//饿汉式
class Single
class Single
{
Privatestatic final Single s=new Single();
PrivateSingle() {}
Publicstatic Single getInstance()
{
Returns;
}
}
//懒汉式
class Single
{
Privatestatic Single s=null;
PrivateSingle(){}
Publicstatic Single getInstance()
{
if(s==null)
{
Synchronized(Single.class)
{
if(s==null)
s=newSingle();
}
}
returns;
}
}
单例模式中懒汉式的隐患
if(instance == null) {
instance = new Single();
}
return instance;
给懒汉添加同步
if(instance == null) {
synchronized(Single.class) {
instance = new Single();
}
}
return instance;
隐患依然存在
同步块内使用判断
synchronized(Single.class) {
if(instance == null) {
instance = new Single();
}
}
return instance;
隐患是没有了,但效率低下
双重判断
If(instance == null) {
synchronized(Single.class) {
if(instance == null) {
instance = new Single();
}
}
}
return instance;
如果在使用单例的设计模式的时候建议是用饿汉式,因为懒汉式会有加载延迟,加载延迟会出现安全问题,出现问题时候可以加载同步函数,但是加同步函数的时候会使其低效,但是可以使用双重判定可以解决低效的问题。
死锁:
就是同步中嵌套同步就产生了死锁。