-------android培训、java培训、期待与您交流! ----------
一 多线程概述
进程:正在进行的程序。每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元。
线程:进程内部的一条执行路径或者一个控制单元。
2 、 jvm 多线程的启动是多线程吗?
两者的区别:
一个进程至少有一个线程
进程在执行过程中拥有独立的内存单元,而多个线程共享内存;
3 、多线程的优势:
java的虚拟机jvm启动的是单线程,就有发生内存泄露的可能,而我们使用java程序没出现这样的问题,
也就是jvm启动至少有两个线程,一个执行java程序,一个执行垃圾回收。所以是多线程。而执行java程序的那个线程为主线程,存在于mian方法中。
4 、线程的弊端:
解决了多部分同时运行的问题,提高效率
5 、什么叫多线程以及多线程的特点:
线程太多会导致效率的降低,因为线程的执行依靠的是CPU的来回切换。
6 、实现多线程的方法:
一个进程中有多个线程,称为多线程。多线程的特点:随机性
实现多线程可以通过继承Thread类和实现Runnable接口。
在定义线程时,建议使用实现Runnable接口,因为几乎所有多线程都可以使用这种方式实现
(1)继承Thread
定义一个类继承Thread类
复写Thread类中的public void run()方法,将线程的任务代码封装到run方法中
直接创建Thread的子类对象,创建线程
调用start()方法,开启线程(调用线程的任务run方法)
//另外可以通过Thread的getName()获取线程的名称。
class Demo extends Thread { public void run() { for(int x=0;x<60;x++) System.out.println("demo run"+x); } } class ThreadDemo { public static void main(String[] args) { Demo d =new Demo();//创建一个线程 d.start(); } }
(2)实现Runnable接口;
定义一个类,实现Runnable接口;
覆盖接口的public void run()的方法,将线程的任务代码封装到run方法中;
创建Runnable接口的子类对象
将Runnabl接口的子类对象作为参数传递给Thread类的构造函数,创建Thread类对象(原因:线程的任务
都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时就必须明确要运行的任务)。
调用start()方法,启动线程。
/* 需求:简单的卖票例子 多个窗口同时卖票 */ class Ticket implements Runnable { private int tick = 100; public void run() { while(true) { if(tick>0) { System.out.println(Thread.currentThread().getName()+".....sale : "+ tick--); } } } } class TicketDemo { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); Thread t3 = new Thread(t); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }
7 、创建线程是为什么要复写 run 方法?
两种方法区别:
(1)实现Runnable接口避免了单继承的局限性
(2)继承Thread类线程代码存放在Thread子类的run方法中
实现Runnable接口线程代码存放在接口的子类的run方法中;
8 、 start()和run() 方法有什么区别?
Thread类用于描述线程。Thread类定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
调用start方法方可启动线程,而run方法只是thread的一个普通方法,调用run方法不能实现多线程;
Start()方法:
start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态,并没有运行,一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体,它包含了要执行的这个线程的内容,Run方法运行结束,此线程随即终止。
Run()方法:
9 、线程的几种状态:
run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条,还是要等待run方法体执行完毕后才可继续执行下面的代码,这样就没有达到多线程的目的。
新建:new一个Thread对象或者其子类对象就是创建一个线程,当一个线程对象被创建,但是没有开启,这个
时候,只是对象线程对象开辟了内存空间和初始化数据。
就绪:新建的对象调用start方法,就开启了线程,线程就到了就绪状态。在这个状态的线程对象,具有执行
资格,没有执行权。
运行:当线程对象获取到了CPU的资源。在这个状态的线程对象,既有执行资格,也有执行权。
冻结:运行过程中的线程由于某些原因(比如wait,sleep),释放了执行资格和执行权。当然,他们可以回到运行
状态。只不过,不是直接回到。而是先回到就绪状态。
死亡:当线程对象调用的run方法结束,或者直接调用stop方法,就让线程对象死亡,在内存中变成了垃圾。
10、sleep()和wait()的区别:
(1)这两个方法来自不同的类,sleep()来自Thread类,而wait()来自Object类。
(2)sleep是Thread的静态类方法,谁调用的谁去睡觉,即使在a线程里调用了b的sleep方法,实际上还是a去睡觉,
要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
(3)sleep()释放资源不释放锁,而wait()释放资源释放锁;
(4)使用范围:wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
二 多线程的安全
1、多线程安全问题:
(1)原因:当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源),由于线程的随机性导致
一个线程对多条语句,执行了一部分还没执行完,另一个线程抢夺到cpu执行权参与进来执行,
此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。
(2)解决方法:对多条操作共享数据的语句进行同步,一个线程在执行过程中其他线程不可以参与进来
2、Java中多线程同步是什么?
同步是用来解决多线程的安全问题的,在多线程中,同步能控制对共享数据的访问。如果没有同步,当一
个线程在修改一个共享数据时,而另外一个线程正在使用或者更新同一个共享数据,这样容易导致程序出
现错误的结果。
3、什么是锁?锁的作用是什么?
锁就是对象
锁的作用是保证线程同步,解决线程安全问题。
持有锁的线程可以在同步中执行,没有锁的线程即使获得cpu执行权,也进不去。
**同步代码快的锁可以使任何对象,但是在进行多线程通信使用同步代码快时,
必须保证同步代码快的锁的对象和,否则会报错。
**同步函数的锁是this,也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是
同一个对象,也就是都是this锁代表的对象。
/*
同步函数用的是哪一个锁呢?
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
通过该程序进行验证。
使用两个线程来买票。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行买票动作。
*/
class Ticket implements Runnable
{
private int tick = 100;
Object obj = new Object();
boolean flag = true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(this)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
}
}
}
}
else
while(true)
show();
}
public synchronized void show()//this
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
}
}
}
class ThisLockDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
// Thread t3 = new Thread(t);
// Thread t4 = new Thread(t);
// t3.start();
// t4.start();
}
}
**静态同步函数的锁是class对象,如果同步函数被静态修饰后,使用的琐是该方法所在类的字节码
文件对象,类名.class
/*
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
*/
class Ticket implements Runnable
{
private static int tick = 100;
//Object obj = new Object();
boolean flag = true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(Ticket.class)
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
}
}
}
}
else
while(true)
show();
}
public static synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
}
}
}
class StaticMethodDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
}
}
4、同步的前提:
(1)必须保证有两个以上线程
(2)必须是多个线程使用同一个锁,即多条语句在操作线程共享数据
(3)必须保证同步中只有一个线程在运行
5、同步的好处和弊端
好处:同步解决了多线程的安全问题
弊端:多线程都需要判断锁,比较消耗资源
6、同步的两种表现形式
(1) 同步代码块 :7 、多线程的单例设计模式:保证某个类中内存中只有一个对象
(2) 同步函数
可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象
考虑到安全问题,一般还是使用同一个对象,相对来说效率较高。
格式:
synchronized(对象)
{
需同步的代码;
}
class Ticket implements Runnable { private int tick = 100; Object obj = new Object(); public void run() { while(true) { synchronized(obj) { if(tick>0) { try{Thread.sleep(10);}catch (Exception e){} System.out.println(Thread.currentThread().getName()+".....sale : "+ tick--); } } } } } class TicketDemo2 { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t);//创建一个线程 Thread t2 = new Thread(t); Thread t3 = new Thread(t); Thread t4 = new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); } }
同步方法是指进入该方法时需要获取this对象的同步锁,在方法上使用synchronized关键字,
使用this对象作为锁,也就是使用了当前对象,因为锁住了方法,所以相对于代码块来说效率相对较低。
格式:
修饰词 synchronized 返回值类型 函数名(参数列表)
{
需同步的代码;
}
在jdk1.5后,用lock锁取代了synchronized,个人理解也就是对同步代码块做了修改,
并没有提供对同步方法的修改,主要还是效率问题吧。
/* 需求: 银行有一个金库。 有两个储户分别存300元,每次存100,存3次。 目的:该程序是否有安全问题,如果有,如何解决? 如何找问题: 1,明确哪些代码是多线程运行代码。 2,明确共享数据。 3,明确多线程运行代码中哪些语句是操作共享数据的。 */ class Bank { private int sum; public synchronized void add(int n) { sum = sum + n; try{Thread.sleep(10);}catch(Exception e){} System.out.println("sum="+sum); } } class Cus implements Runnable { private Bank b = new Bank(); public void run() { for(int x=0; x<3; x++) { b.add(100); } } } class BankDemo { public static void main(String[] args) { Cus c = new Cus(); Thread t1 = new Thread(c); Thread t2 = new Thread(c); t1.start(); t2.start(); } }
8 、死锁(1)饿汉式:
class Single { private Single(){}//将构造函数私有化,不让别的类建立该类对象 private static final Single s=new Single();//自己建立一个对象 public static Single getInstance()//提供一个公共访问方式 { return s; } }
(2)懒汉式:
class Single { private Single(){} private static Single s; public static Single getInstance() { if(s==null) s=new Single(); return s; } }
饿汉式和懒汉式的区别:
**
饿汉式是类一加载进内存就创建好了对象;
懒汉式则是类加载进内存的时候,对象还没有存在,只有调用了getInstance()方法时,对象才开始创建。
**
懒汉式是延迟加载,如果多个线程同时操作懒汉式时就有可能出现线程安全问题,解决线程安全问题
可以加同步来解决。但是加了同步之后,每一次都要比较锁,效率就变慢了,
所以可以加双重判断来提高程序效率。
如将上述懒汉式的Instance函数改成同步:
class Single { private Single(){} private static Single s; public static Single getInstance() { if(s==null) { synchronized(Single.class)//静态同步函数锁是类名.class { if(s==null) s=new Single(); } } return s; } }
两个线程对两个同步对象具有循环依赖时,就会发生死锁。即同步嵌套同步,而锁却不同。
/* 死锁。 同步中嵌套同步。 */ class Ticket implements Runnable { private int tick = 1000; Object obj = new Object(); boolean flag = true; public void run() { if(flag) { while(true) { synchronized(obj) { show(); } } } else while(true) show(); } public synchronized void show()//this { synchronized(obj) { if(tick>0) { try{Thread.sleep(10);}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"....code : "+ tick--); } } } } class DeadLockDemo { public static void main(String[] args) { Ticket t = new Ticket(); Thread t1 = new Thread(t); Thread t2 = new Thread(t); t1.start(); try{Thread.sleep(10);}catch(Exception e){} t.flag = false; t2.start(); } }
class Test implements Runnable { private boolean flag; Test(boolean flag) { this.flag = flag; } public void run() { if(flag) { while(true) { synchronized(MyLock.locka)//自定义锁 { System.out.println(Thread.currentThread().getName()+"...if locka "); synchronized(MyLock.lockb) { System.out.println(Thread.currentThread().getName()+"..if lockb"); } } } } else { while(true) { synchronized(MyLock.lockb) { System.out.println(Thread.currentThread().getName()+"..else lockb"); synchronized(MyLock.locka) { System.out.println(Thread.currentThread().getName()+".....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(); } }