-----------android培训、java培训、java学习型技术博客、期待与您交流!------------
多线程
什么是 进程
是一个正在执行中的程序。
进程是指一个内存中运行的应用程序,每个进程都有自己独立的一块内存空间,一个进程中可以启动多个线程。比如在Windows系统中,一个运行的exe就是一个进程。
什么是线程
线程就是进程中的一个独立的控制单元。只要进程中有一个线程在执行,进程就不会结束。
一个进程中至少有一个线程。进程中的多个线程共享进程的内存。
什么事是多线程
一般来说,当运行一个应用程序的时候,就启动了一个进程,当然有些会启动多个进程。启动进程的时候,操作系统会为进程分配资源,其中最主要的资源是内存空间,因为程序是在内存中运行的。在进程中,有些程序流程块是可以乱序执行的,并且这个代码块可以同时被多次执行。实际上,这样的代码块就是线程体。线程是进程中乱序执行的代码流程。当多个线程同时运行的时候,这样的执行模式成为并发执行。
多线程的出现能让程序产生同时运行效果。可以提高程序执行效率。
二、创建线程的方式
创建线程共有两种方式:继承方式和实现方式
继承方式
第一种方式就是通过继承Thread类,然后复写其run方法的方式来创建线程。
注意:继承Thread的子类新建立的对象直接调用run()和调用start()方法的区别 !!! 如下图”
第二种创建线程的方式:实现Runnable接口
第二种方法 程序示例:
class runnable
{
public static void main(String[] args)
{
myRunnable run=new myRunnable();
// new Thread(run).start();
// new Thread(run).start();
Thread t = new Thread(run);
Thread t1 = new Thread(run);
t.start();
//t.start();
t1.start();
System.out.println("Hello World!");
}
}
class myRunnable implements Runnable
{
private int k=20;
public void run()
{
while(true) //会出现死循环,用ctrl+c 结束
{
if(k>0)
{
System.out.println(k--);
}
}
}
}
实现方式好处:避免了单继承的局限性。在定义线程时,建议使用实现方式。
线程安全问题
1、导致安全问题的出现的原因:
当多条语句在操作同一线程共享数据时,一个线程对多条语句只执行了一部分,还没用执行完,另一个线程参与进来执行。导致共享数据的错误。
简单的说就两点:
a、多个线程访问出现延迟。
b、线程随机性 。
注:线程安全问题在理想状态下,不容易出现,但一旦出现对软件的影响是非常大的。
解决办法——同步
对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
在java中对于多线程的安全问题提供了专业的解决方式——synchronized(同步)
这里也有两种解决方式,一种是同步代码块,还有就是同步函数。都是利用关键字synchronized来实现。
同步代码块--synchronized(obj)
用法:
Object obj = new Object();
synchronized(obj)
{
..............要同步的多线程运行代码
}
对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
同步函数--synchronized(this)
格式:
在函数上加上synchronized修饰符即可。
函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。
3、同步的前提
a,必须要有两个或者两个以上的线程。
b,必须是多个线程使用同一个锁。
4、同步的利弊
好处:解决了多线程的安全问题。
弊端:多个线程需要判断锁,较为消耗资源。
5、如何寻找多线程中的安全问题
a,明确哪些代码是多线程运行代码。
b,明确共享数据。
c,明确多线程运行代码中哪些语句是操作共享数据的。
静态函数的同步方式--类名.class
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也不可以定义this。静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。如:
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。类名.class
死锁
当同步中嵌套同步时,就有可能出现死锁现象。
/*
写一个简单的死锁程序
*/
class LockTest implements Runnable
{
private boolean flag;
LockTest(boolean flag)
{
this.flag=flag;
}
public void run()
{
if(flag)
{
synchronized(LockClass.locka)
{
System.out.println(Thread.currentThread().getName()+"if_locka"); //第一个线程一直停留在这等待B锁
synchronized(LockClass.lockb)
{
System.out.println(Thread.currentThread().getName()+"if_lockb");
}
}
}
else
{
synchronized(LockClass.lockb)
{
System.out.println(Thread.currentThread().getName()+"else_lockb"); //第二个线程一直停留在这等待A锁
synchronized(LockClass.locka)
{
System.out.println(Thread.currentThread().getName()+"else_locka");
}
}
}
}
}
//定义两个锁
class LockClass
{
static Object locka = new Object(); //A锁 LockClass.locka
static Object lockb = new Object(); //B锁 LockClass.lockb
}
class deadlock
{
public static void main(String[] args)
{
//创建2个进程,并启动
new Thread(new LockTest(true)).start(); //进入A锁 等待B锁
new Thread(new LockTest(false)).start(); //进入B锁,等待A锁
}
}
结果:第一遍通过,第二遍卡住! 这个只是一次循环,多次循环 不死的几率很小
线程间通信
其实就是多个线程在操作同一个资源,但是操作的动作不同。
1、使用同步操作同一资源的示例:
--------------------------------------------
wait()
notify(),
notifyAll(),
都使用在同步中,因为要对待有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁!
用来操作线程为什么定义在了Object类中?
a,这些方法存在与同步中。
b,使用这些方法时必须要标识所属的同步的锁。同一个锁上wait的线程,只可以被同一个锁上的notify唤醒。
c,锁可以是任意对象,所以任意对象调用的方法一定定义Object类中。
也就是说:等待和唤醒必须是同一个锁!!
2)wait(),sleep()有什么区别?
wait():释放cpu执行权,释放锁。
sleep():释放cpu执行权,不释放锁。
3)为甚么要定义notifyAll?
因为在需要唤醒对方线程时。如果只用notify,容易出现只唤醒本方线程的情况。导致程序中的所以线程都等待。
2、JDK1.5中提供了多线程升级解决方案。
将同步synchronized替换成显示的Lock操作。将Object中wait,notify,notifyAll,替换成了Condition对象。该Condition对象可以通过Lock锁进行获取,并支持多个相关的Condition对象。
升级解决方案的示例: