黑马程序员——多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一，多线程概述

1，进程：是一个正在执行的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

2，线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。只要进程中有一个线程在执行，进程就不会结束，

（一个进程中至少有一个线程）

3，多线程：

在java虚拟机启动的时候会有一个java.exe的执行程序，也就是一个进程。该进程中至少有一个线程负责java程序的执行。

而且这个线程运行的代码存在于main方法中。该线程称之为主线程。JVM启动除了执行一个主线程，还有负责垃圾回收机制的线程。

像种在一个进程中有多个线程执行的方式，就叫做多线程。

多线程的好处：解决了多部分代码同时运行的问题。

多线程的弊端：线程太多，会导致效率的降低。

其实，多个应用程序同时执行都是CPU在做着快速的切换完成的。这个切换是随机的。CPU的切换是需要花费时间的，从而导致了效率的降低。

二，创建线程的两种方式

（1 ）继承Thread类

步骤：

1，定义类继承Thread

2，复写Thread类中的run方法（目的：将自定义代码存储在run方法中，让线程运行）

3，创建这个类的实例对象，相当于创建一个线程

4，调用线程的start方法（该方法有两个作用：启动该线程，调用run方法）

注意：覆盖run方法的原因：run方法是用于存储线程运行的代码。

start( )和run( )方法的区别：

start( )是用于开启线程并执行线程的run方法。

run（）仅仅是对象调用方法，而线程创建了并没有运行。

下面是一段线程代码：

class Demo extends Thread
{
private String name ;
Demo(String name)
{
this.name = name;
}
public void run()
{
for(int x = 0; x < 10; x++)
{
System.out.println(name + "...x=" + x + "...ThreadName=" + Thread.currentThread ().getName());
}
}
}

class ThreadDemo1
{
public static void main(String[] args)
{
Demo d1 = new Demo("zhangsan");
Demo d2 = new Demo("李四");
d1.start(); //开启线程，调用run方法。
d2.start();
for(int x = 0; x < 20; x++)
{
System.out.println("x = " + x + "...over..." + Thread.currentThread().getName());
}
}
}

运行结果：



通过结果发现运行结果每一次都不同，为什么呢？

因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行，明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）

cpu在做着快速的切换，以达到看上去同时运行的效果。

我们可以形象的把多线程的运行行为是在互相抢夺cpu的执行权，这就是多线程的一个特性。随机性，谁抢到谁执行，至于执行多长，cpu说了算。

同时还可以看出原来线程都有自己默认的名称，Thread_编号，该编号从0开始。

线程的运行状态：

被创建，运行，冻结，消亡

sleep方法需要指定睡眠时间，单位是毫秒。比如：wait(); notify();

一个特殊的状态：就绪（临时状态/阻塞）。具备了执行资格，但是还没有获取资源

冻结：放弃了执行资格。sleep(); wait(); notify();唤醒后先到临时状态等待执行

获取线程对象及名称：Thread.currentThread().getName()

设置线程名称：setName或者构造函数(super)

（2）实现Runnable接口

步骤：

1，定义类，实现Runnable接口。

2,，覆盖Runnable接口中的run方法。（将线程要用的代码存放在run方法中）

3，通过Thread类建立线程对象。

4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

为什么要将Runnable接口的子类对象传递给Thread的构造函数？

因为，自定义的run方法所属的对象是Runnable接口的子类对象。

所以要让线程去执行指定对象的run方法。就必须明确该run方法所属的对象。

实现方式和继承方式有什么区别呢？

实现方式的好处：避免单继承的局限性。

在定义线程时，建议使用实现方式。

两种方式的区别：

继承Thread：线程代码存放在Thread子类run方法中。

实现Runnable：线程代码存放在接口的子类的run方法中。

接口的代码示例：

/*
需求：简单的卖票程序
多个窗口同时卖票
*/
class Ticket implements Runnable//extends Thread
{

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();

//Ticket t1 = new Ticket();
//Ticket t2 = new Ticket();
//Ticket t3 = new Ticket();
//Ticket t4 = new Ticket();

/*t1.start();
t2.start();
t3.start();
t4.start();*/

}
}

三，多线程的安全问题

问题的原因：

当多条语句操作同一线程共享数据时，一个线程对多条语句执行了一部分，还没执行完，

另一个线程参与进来运行，导致共享数据的错误。

解决办法：

对多条操作共享数据的语句，只让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

在java中对于多线程的安全问题提供了专业的解决方式——synchronized（同步）

这里也有两种解决方式，一种是同步代码块，还有就是同步函数。都是利用关键字synchronized来实现。

第一种方式：同步代码块

ynchronize(对象)

{

需要被同步的代码

}

对象如同锁，持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

同步的前提：

1，必须要有两个或两个以上的线程。

2，必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。

弊端：多个线程需要判断，较为消耗资源。

下面是对卖票的代码进行修改（加了同步代码块）：

class Ticket implements Runnable{
private int num = 100;
Object obj = new Object();

public void run(){
while(true ){
synchronized(obj ){
if(num > 0){
System.out.println(Thread.currentThread().getName() + "...sale..." + num--);
}
}
}
}
}

class TicketDemo1{
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();
}
}

运行结果：



多线程中，判断程序是否有安全问题，如果有，如何解决？如何找问题？

1，明确哪些代码是多线程运行代码。

2，明确共享数据。

3，明确多线程运行代码中哪些语句是操作共享数据的

第二种方式：同步函数

格式：

在函数上加上synchronized修饰符即可

同步函数用的锁是this

同步函数被静态修饰后，使用的锁是该方法所在类的字节码文件对象

函数需要被对象调用，那么函数都有一个所属对象引用，就是this

所有同步函数使用的锁都是this

如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证。发现不是this。因为静态方法中不可以定义this。

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class。 该对象的类型是Class。

同步函数和同步代码块的区别：

1，同步函数的锁是固定的this。

2，同步代码块的锁是任意的对象。

建议使用同步代码块。

由于同步函数的锁是固定的this，同步代码块的锁是任意的对象，那么如果同步函数和同步代码块都使用this作为锁，就可以实现同步。

示例：

class Ticket implements Runnable{
private static int num = 100;
Object obj = new Object();
boolean flag = true;

public void run(){
if(flag ){
while(true ){
synchronized(Ticket.class){//this.getClass()
if(num > 0){
try{
Thread. sleep(10);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...obj..." + num--);
}
}
}
} else
while(true )
show();
}

public static synchronized void show(){
if(num > 0){
try{
Thread. sleep(10);
} catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "...function..." + num--);
}
}
}

class SynFunctionLockDemo1{
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(InterruptedException e){
e.printStackTrace();
}
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{
public static final Object locka = new Object();
public static final Object lockb = new Object();
}

class DeadLockDemo{
public static void main(String[] args){
Test a = new Test(true );
Test b = new Test(false );

Thread t1 = new Thread(a);
Thread t2 = new Thread(b);

t1.start();
t2.start();
}
}

运行结果：



五，线程间通信

其实就是线程间在操作同一资源，但是操作的动作不同。

下面是多个线程操作统一资源的示例：

/*
线程间通讯
其实就是多个线程在操作同一个资源
但是操作动作不同
*/
class Res
{
String name;
String sex;
boolean flag;
}

class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x=0;
while(true)
{
synchronized(r)
{
if(r.flag)
try{r.wait();}catch(Exception e){}
if(x==0)
{
r.name="jake";
r.sex = "man";
}
else
{
r.name="李丽";
r.sex= "女女女";
}
x = (x+1)%2;
r.flag = true;
r.notify();
}
}
}
}

class Output implements Runnable
{
private Res r;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
synchronized(r)
{
if(!r.flag)
try{r.wait();}catch(Exception e){}
System.out.println(r.name+"....."+r.sex);
r.flag = false;
r.notify();
}
}
}
}

class  InputOutDemo
{
public static void main(String[] args)
{
Res r = new Res();

Input i = new Input(r);
Output o = new Output(r);

Thread t1 = new Thread(i);
Thread t2 = new Thread(o);

t1.start();
t2.start();
}
}

运行结果：



注意：

等待唤醒机制：wait()，notify()，notifyAll()都使用在同步中，因为要对持有监视器（锁）的线程操作。

所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义在Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的那个锁。

只有同一个锁上的被等待线程，可以被同一个锁上的notify唤醒。

不可以对不同锁中的线程进行唤醒。

wait和sleep区别？

1，wait可以指定时间也可以不指定。sleep必须指定时间。

2，在同步中时，对CPU的执行权和锁的处理不同。

wait：释放执行权，释放锁。

sleep：释放执行权，不释放锁。

生产者与消费者问题

对于多个生产者和消费者

1，为什么要定义while循环判断标记？

让被唤醒的线程再一次判断标记。

2，为什么定义notifyAll？

因为需要唤醒对方线程。只用notify容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。

JDK1.5升级以后：

将同步synchronized替换成显示Lock操作。

将Object中的wait()，notify()，notifyAll()，替换成Condition对象。

该对象可以Lock锁，进行获取。

import java.util.concurrent.locks.*;
class ProducerConsumerDemo2
{
public static void main(String[] args)
{
Resource res = new Resource();
Producer pro   = new Producer(res);
Consumer con   = new Consumer(res);

Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);

t1.start();
t2.start();
t3.start();
t4.start();

}
}

class Resource
{
private String name;
private int count=1;
private boolean flag = false;

private Lock lock = new ReentrantLock();
private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition();

public  void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_pro.await();
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者...."+this.name);
flag = true;
condition_con.signal();
}

finally
{
lock.unlock();
}

}

public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"....消费者.............."+this.name);
flag = false;
condition_pro.signal();
}
finally
{
lock.unlock();
}

}

}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.set("+商品+");
}
catch (InterruptedException e)
{

}

}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch (InterruptedException e)
{
}

}
}
}

运行结果：



该示例中实现了本方只唤醒对方的操作。

停止线程

stop方法已经过时

1，定义循环结束标记

因为线程运行代码一般都是循环，只要控制了循环即可。

2，使用interrupt（中断）方法

该方法是结束线程的冻结状态，使线程回到运行状态中来。

如何停止线程。

只有一种，run方法结束，开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束。也就是线程结束。

特殊情况：

当线程处于冻结状态。就不会读取到标记。那么线程就不会结束。

线程的其他方法

setDaemon(boolean b)标记为守护线程（后台线程），当所有前台线程结束后自动结束。

1，当正在运行的线程都是守护线程时，Java虚拟机退出

2，必须在线程启动前调用

join( )抢夺cpu执行权。join可用来临时加入线程执行。

当A线程执行到了B线程的join()方法时。A就会等待。等B线程都执行完，A才会执行。join可以用来临时加入线程执行。

自定义线程名称：

toString()方法包含线程名称，优先级和线程组。

设置优先级：

setPriority( )所有线程都默认为5，最大是10

凡是数据是固定的，定为常量。数据共享的定为静态static

yield()是指临时停止当前正在运行的线程。

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------