一、多线程
在说到多线程,我先简单说一下线程的概念,线程就是在进程中一个负责程序执行的控制单元,也叫执行路径。那么多线程就是一个进程中有多个执行路径称之为多线程。
为什么会有多线程,就是因为我们想让多个部分代码同时在运行,打个很简单的比方就是,射击游戏中子弹在运行着,人物也同时可以跑动,这就是线程在同时运行着他们,每一个线程都有自己的内容,这个内容就称为线程要执行的任务.
但是多线程有优点,也有弊端.它解决了多部分同时运行的问题.但是线程太多对导致效率降低.就比如电脑开了一个软件运行起来很流畅,我要是开十几个软件就卡的动不了.应用程序的执行由cpu做着快速切换完成的(这个切换是随机的),也就是说cpu其实就是一个"单线程",但是做着快速的切换去完成多个应用同时在运行,这个切换都是以毫秒计算,所以看不出来,但是应用程序多了,自然也就变慢了.哦了.
JVM启动时就会启动多个线程,只是有两个我们可以分析的出来.
1.执行main函数的线程;2.负责垃圾回收的线程.finalize()当垃圾回收器确定不存在对该对象更多引用时,由对象垃圾回收器调用此方法).
二、多线程详细图解
cpu的执行资格:可以被cpu处理,在处理队列中排队.
cpu的执行权:正在被cpu处理
创建线程的两种方式:1.定义类继承Thread类,覆盖run方法,直接创建Thread的子类对象创建线程,调用start方法开启;
JVM创建的主线程的任务都定义在主函数中,自定义的线程需要封装在run方法中,通过start开启进入run方法自定义的的线程.
2.定义类实现Runnable接口,覆盖接口中的run方法,将线程代码封装在run方法中,通过Thread类创建线程对象,并将Runnable接口子类对象作为Thread类的构造函数的参数传递.调用线程对象的start方法开启.
class Demo implements Runnable
{
public void run()
{
show();
}
public void show()
{
//方法内容...
}
}
public static void main(String[] agrs){
Demo d = new Demo();
Thread t = new Thread(d);
t.start();
}第二种方式细节:Runnable他的出现仅仅是将线程的任务进行了对象封装,第一种方式继承Thread类,是说我们是线程的子类,任务只是我们对象中的一部分内容.而第二种方式是单独将线程的任务用对象封装起来,类型:Runnable
好处:(实现Runnable接口的好处也是区别)
1.将线程的任务从线程的子类中分离出来,进行了单独的封装,按照面向对象的思想将任务封装成对象.
2.避免了java单继承的局限性.所以第二种方式较为常用.
三、线程安全问题
原因:既然是多线程,肯定涉及到1.多个线程在操作共享的数据;2.操作共享数据的线程代码有多余.
当一个线程在执行操作共享的多条代码过程中,其他线程参与了运算,就会导致线程安全问题的产生.这时就出现了一个同步的概念.它是多个线程使用一个锁,当这个锁被一个线程拿着时,别的线程是无法继续执行的,解决了线程安全问题,但同时同步外的线程都会判断同步锁,效率也相对降低了.对于这个锁,可以是任意的对象.
//方式一:同步代码块
synchronized(对象/相当与锁){
// 需要同步的代码;
}
//方式二:同步函数
public synchronized void show()
{
}在这里同步函数的锁是this.同步代码快的锁是任意对象(开发建议)
在函数是静态的时候,new的对象不可能成为同步的锁,静态随类的加载而加载,在new对象之前,但是在字节码进入内存要先封装对象,这个对象就是当前class文件所属的对象.写法:当前类名.class,所以静态同步函数使用的锁是该函数所属字节码文件对象。
在这里说一下单例设计模式的多线程问题(面试题)
延迟加载单例设计模式(懒汉式)
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()}
}
}
}
}根据程序分析,如果有多个线程进入,其中一个线程抢到Single.class的锁的情况下,这时s==null,会new一个对象,当下一个线程进来依然要判断是否为空,为了提高效率,我们将是否为空的判断在获得锁之前就先判断,这样就避免了锁的和对象是否为空的重复判断。四、死锁
常见的情景之一:同步的嵌套
package com.qyc.dao;
class Ticket implements Runnable {
boolean flag = true;
Ticket(boolean flag) {
this.flag = flag;
}
/*
* 分析:
* 假设a先线程进入了if(),打开了locka锁,输出了...if....a
* 这时b也进入了else,打开了lockb锁.输出了...if....b
* 这时a想打开lockb锁,可是else中b持有着,所以a还打不开,就在这里等着b走完else将lockb锁释放
* 这时b需要打开locka锁,走出else才能释放lockb锁,但是a在if中持有着locka锁,b也打不开,也在这等待着a走完if将locka锁释放
* 最终都停在这里出不去,这就是死锁
* 如何解决:
* 首先找到问题的所在,让他们共用的锁在释放后,才允许下一个线程持有这个锁,这个还是主要分析具体的情况,这代码就是一个死锁的代码示例
* */
public void run() {
if (flag) {
synchronized (Mylock.locka) {
System.out.println(Thread.currentThread().getName()
+ "...if....a");
synchronized (Mylock.lockb) {
System.out.println(Thread.currentThread().getName()
+ "...if....b");
}
}
} else {
synchronized (Mylock.lockb) {
System.out.println(Thread.currentThread().getName()
+ "...else....a");
synchronized (Mylock.locka) {
System.out.println(Thread.currentThread().getName()
+ "...else....b");
}
}
}
}
}
class Mylock {
public static final Object locka = new Object(); //locka用于线程a的锁
public static final Object lockb = new Object(); //lockb用于线程b的锁
}
public class Test1 {
public static void main(String[] args) throws InterruptedException {
Ticket a = new Ticket(true); //让a走if语句
Ticket b = new Ticket(false);//让b走else语句
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);
t1.start(); //开启线程
t2.start();
}
}五、JDK1.5版本后出现的新特性
Lock lock = new Reetrantlock();
原来同步代码块,对于锁的操作是隐式的,JDK1.5后将同步和锁封装了对象,并将操作锁的隐式方式定义到了该对象中,将隐式动作变成了显示动作。
lock替换了synchronized方法和语句使用;Condtion替代了Object监视器方法使用。它对Object监视器对象,自己单独封装了一组对象,并可以将多个Condition对象使用一个锁
优点分析:以前一个锁上只有一组监视器,这个监视器既监视着生产者又监视着消费者,也就是有可能将生产者或消费者全部wait()或notify();具有着不确定性,而有了Condition监视器对象,可以来分组分别监视生产者和消费者.
package com.qyc.dao;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class Product {
private String water;
private int count = 0;
// 创建一个锁对象
Lock lock = new ReentrantLock();
// 创建两个监视器,一个监视生产者,一个监视消费者
Condition con1 = lock.newCondition();
Condition con2 = lock.newCondition();
private boolean flag = false;
public void production(String water) {
lock.lock();
try {
while (flag) {
try {
con1.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.water = water;
count++;
System.out.println(Thread.currentThread().getName() + "生产第" + count
+ "瓶" + water);
flag = true;
con2.signal();
} finally {
lock.unlock();
}
}
public void consumption() {
lock.lock();
try {
while (!flag) {
try {
con2.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "消费第" + count
+ "瓶" + water);
flag = false;
con1.signal();
} finally {
lock.unlock();
}
}
}
class Production implements Runnable {
private Product p;
Production(Product p) {
this.p = p;
}
public void run() {
while (true)
{
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
p.production("矿泉水");
}
}
}
class Consumption implements Runnable {
private Product p;
Consumption(Product p) {
this.p = p;
}
public void run() {
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
p.consumption();
}
}
}
public class SynchronizedTest1 {
public static void main(String[] args) {
Product pro = new Product();
Production p = new Production(pro);
Consumption c = new Consumption(pro);
Thread t0 = new Thread(p);
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
Thread t3 = new Thread(c);
t0.start();
t1.start();
t2.start();
t3.start();
}
}
六、其他
停止线程(Interrupt()):对于停止有一种方法stop(),但是这种方法已经过时。还有一种方法是:run方法的结束.任务中都有循环,要控制循环就要结束循环.但是如果线程处于了冻结状态,无法读取标记,如何结束?可以使用 Interrupt()方法将线程从冻结状态强制恢复到运行状态中来,让线程具备CPU的执行资格.强制会发生InterruptedException异常,记得处理。
守护线程(setDaermon):可以理解为后台线程,又称用户线程.注意:1.该方法必须在启动线程之前调用;2.当运行的线程都是守护线程,Java虚拟机是不管的,直接退出。
等待线程终止(join()方法):临时加入一个线程去运算时可使用join方法。
返回线程的字符串表示形式(toString()):包括线程名称、优先级(1~10)、线程组。更改线程优先级:setPriority(int newPriority)
线程组(ThreadGroup):可封装多个线程,对其操作.
暂停当前正在执行的线程(yield()):暂时释放一下执行权.
8622



被折叠的 条评论
为什么被折叠?



