黑马程序员_java多线程

——- android培训、java培训、期待与您交流！ ———-

概述

线程是进程中的内容，而每一个应用程序里面至少有一个线程。

1.什么是线程？

线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)。

2.什么是进程？

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

示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

public static void main(String[] args){

for(int x = 1; x<4000;x++)

System.out.println(“Hello Word!”);}



在我们启动JVM执行这个程序时，会有一个叫java.exe的进程。

因为进程中至少有一个线程，所以说明该进程中至少有一个线程在负责java程序的执行。

而这个线程运行的代码存放在main方法中，所以该线程也称为主线程。

3.多线程存在的意义

多线程的出现可以让我们程序中的部分能产生同时运行的效果。

例如：

其实如果更细节的说明，在JVM启动时是不止一个线程的，还有负责垃圾回收机制的线程。

如果JVM只有一个线程，没有垃圾回收线程，会有什么后果呢？

主线程在一直运行，在执行过程中堆内存中会存放很多很多垃圾，在主线程执行完后在做垃圾回收动作。可是，如果主线程在执行过程中垃圾太多堆内存放不下了，主线程就会先停下把垃圾先回收，解决之后在往下继续执行，而它在解决垃圾时我们的程序就会停止，这就很不合理。

如果JVM有多个线程，主线程在运行程序，还有一个线程在负责垃圾回收，这样程序就会更优化。

4.如何在程序中自定义线程？

Java给我们提供了对像线程这类事物的描述，该类是Thread类。

该类中定义了，创建线程对象的方法(构造函数),提供了要被线程执行的代码存储的位置(run()方法)，还定义了开启线程运行的方法(start())。

Java还给我们提供了一个规则，实现Runnable接口。如果自定义类不继承Thread，也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。

创建线程

方式一：继承Thread类

步骤：

1.定义一个类，继承Thread类

2.复写Thread类中的run方法，方法中写需要在新线程中执行的代码

3.创建Thread类的子类对象，调用线程的start方法

代码实现：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

public class Demo extends Thread{

public void run(){//复写Thread类中的run方法

//这里用来存放我们要线程执行的代码

System.out.println(“我的线程1”);

}

}

public class DemoTest{

public static void main(String[] args){

Demo d = new Demo();//创建一个线程

d.start();//开启线程并执行该线程的run方法

//d.run();//仅仅是对象调用方法，而线程创建了并没有运行

//也可以用匿名的方式

//new Demo().start();

}

}

1）.为什么要覆盖run方法呢？

我们为什么要开启线程，就是为了要让线程去执行我们定义的某些代码，让这些代码起 到同时运行的效果。

Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该存储 功能就是run方法。也就是说Thread类中的run方法是用于存储线程要运行的代码。

所以我们覆盖父类中run方法，在run方法中存放我们要执行的代码。

2）.start方法的作用

该方法有两个作用：启动线程，调用并执行run方法。

注意：如直接调用run()方法，则是主线程执行其中代码，不会开启新线程。

方式二：实现Runnable

步骤：

1. 定义类实现Runnable接口

2.覆盖Runnable接口中的run方法，将多线程要运行的代码存入其中。

3.通过Thread类建立线程对象，并将Runnable接口的子类对象作为参数传递给Thread的构造函数。

4.调用Thread对象的start方法开启线程。

代码实现：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

public class Demo implements Runnable{

public void run(){

//将线程要运行的代码存放在该run方法中

Sy
4000
stem.out.println(“我的线程2”);

}

}

public class DemoTest{

public static void main(String[] args){

Demo d = new Demo();//这里不是创建线程

Thread t = new Thread(d);//这里是创建线程

t.start();//启动线程

//匿名的方式

//new Thread(new Demo()).start();

}

}

注意：实现Runnable时这个类还不是线程，创建线程的是Thread类对象或Thread子类对象。

1).为什么要设计Runnable接口？

假设我们有两个类A和B，它们有一些共性代码，我们通过向上的不断抽取，出现了一个父类。可是A类中有一部分代码是需要被多线程所执行，因为java支持的是单继承，它已经继承了一个类了，所以不能在继承Thread类。java支持多实现所以就设计了Runnable接口。

2).Runnable接口应该由哪些类来实现？

Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个名称为run的无参数方法。

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

因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象传递给Thread。让Thread线程去使用该对象调用其run方法。

4).继承Thread类和实现Runnable接口建立线程有什么区别?

1.它们线程代码存放位置不同

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

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

2.局限性

实现Runnable接口避免了单继承的局限性。而且实现Runnable接口这个对象中的数据共享(如果不用静态修饰共享数据是在堆内存中)。

注意：在定义线程时，建议使用实现Runnable接口方式。

线程运行状态



临时状态：有执行资格，没有执行权。

冻结状态：没有执行资格的情况下。

运行状态：有执行资格，有执行权。

sleep方法与wait方法的区别？

sleep()：不会释放对象锁,有执行权,时间结束后,自动恢复线程。

wait()：释放对象锁,进入等待此对象线程池中,只有针对此对象发出notify方法或notifyAll方法后此线程才进入临时状态准备获得执行权进入运行状态。

注意：其中的stop方法现在已经过时用不了，他被新方法interrupt方法所代替。冻结状态的线程都会在线程池中。

同步

我们在运行多线程代码时发现运行结果每一次都不同，说明多线程具备随机性，因为这是由CPU不断的快速切换造成的。这就有可能会产生问题。

问题产生的原因：

1，多线程代码中有操作共享数据。

2，多条语句操作该共享数据。

当具备这两点时：有一个线程对多条操作共享数据的代码只执行了一部分时，另一个线程就开始参与执行，这就会发生数据错误。

解决方法：当一个线程在执行多条操作共享数据代码时，其它线程即使获取了执行权，也不可以参与操作。

Java对这种解决方式提供了专业的代码——同步。

同步的原理：就是将部分操作功能数据的代码进行加锁(也叫监视器)。

同步的前提：

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

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

同步的好处与弊端：

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

弊端：较为消耗资源，同步嵌套后容易死锁。

什么是死锁？

代码示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

class Test implements Runnable

{

private boolean flag;//定义一个布尔型变量

Test(boolean flag)

{

this.flag = flag;

}

public void run(){
if(flag){
//同步代码块的嵌套
synchronized(DuiXiang.t1){//锁1
System.out.println("if ----1");

synchronized (DuiXiang.t2){//锁2
System.out.println("if----2");
}
}

}
else{
synchronized(DuiXiang.t2){//锁2
System.out.println("else----2");
synchronized (DuiXiang.t1){//锁1
System.out.println("else----1");
}
}
}
}

}

class DuiXiang{//为了方便测试，所以把对象单独提取出来

static Object t1 = new Object();//定义一个静态的Object对象

static Object t2 = new Object();

}

class TestDemo{

public static void main(String[] args){

Thread h1 = new Tread(new Tesst(true));//创建线程

Thread h2 = new Tread(new Tesst(false));

h1.start();//启动线程

h2.start();

}

}

注意：我们在开发时一定要注意避免死锁。

同步的表现形式：

1. 同步代码块

[java] view plaincopy在CODE上查看代码片派生到我的代码片

synchronized(对象)｛

需要被同步的代码

｝

2. 同步函数

1）.一般同步函数

[java] view plaincopy在CODE上查看代码片派生到我的代码片

public synchronized void 方法名(){

需要被同步的代码

}

2).静态同步函数

[java] view plaincopy在CODE上查看代码片派生到我的代码片

public synchronized static void 方法名(){//静态同步函数

需要被同步的代码

}

同步代码快与同步函数有什么不同？

它们的锁不同：

同步代码块：锁是任意对象。

同步函数：一般同步函数是this。静态同步函数是类名.class，是该类的字节码文件对象(涉及示例：单例设计模式的懒汉式)。

如何找安全问题？

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

2.明确共享数据。

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

注意：一定要明白哪里可以用同步哪里不可以用，也不可以把run方法都放到同步里，那样就相当成了单线程。

多线程的一些方法

currentThread():获取当前正在执行的线程对象

getName():获取线程名称

Thread.currentThread().getName()：线程名称

设置线程名称：

1. setName();

2. 构造函数

类名(String name){

super(name);//父类有这个构造函数，所以直接调用就行

}

设置线程名称的意义

我们想要知道当前到底是哪一个线程在运行，我们可以获取其名称并进行判断。

wait()：等待。//这里会发生异常

notify()：唤醒一个。

notifyAll()：唤醒线程池中的所有。

上面这三个都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。

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

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

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

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

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

ThreadGroup():线程组。一般情况下，是谁开启这个线程的，这个线程就属于哪个组。

toString():返回该线程的字符串表示形式，包括线程名称、优先级和线程组。一般用的不多。

多线程示例

线程间通信：就是多个线程在操作同一个资源，但操作的动作不同，如：我们有一些数据，a在往里存，b在往出取。

等待唤醒机制示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

class XianCheng {

public static void main(String[] args) {

Res r = new Res();

new Thread(new Input(r)).start();//创建线程并启动

new Thread(new Output(r)).start();

}

}

class Res{

private String name;//姓名

private String sex;//性别

private boolean fal;//默认是false

public synchronized void set(String name,String sex){

if(fal)//判断

try {

this.wait();//这里会出现异常，所以只能try或抛

} catch (InterruptedException e) {

e.printStackTrace();

}

this.name = name;

this.sex = sex;

fal = true;

this.notify();//唤醒一个线程

}

public synchronized void out(){
if(!fal)//这里是不等于ture，因为上面给付了true
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(name+"----------"+sex);
fal = false;
this.notify();
}

}

//输入姓名 性别

class Input implements Runnable{

private Res r;//建立Res的引用，确保拿到的是同一个对象

Input(Res r){

this.r = r;

}

public void run() {

int x = 0;

while(true){

if(x==0)

r.set(“小丽”, “女”);

else

r.set(“Jack”, “man”);

x=(x+1)%2;

}

}

}

//输出姓名 性别

class Output implements Runnable{

private Res r;

Output(Res r){

this.r = r;

}

public void run() {

while(true)

r.out();

}

}

等待的线程放在哪里呢？

在线程运行时内存中会建立一个线程池，等待线程都存在这个线程池中，当我们notify时唤醒的都是线程池中的线程，通常唤醒第一个被等待的,因为它是按顺序往里存的。

停止线程与守护线程

如何停止线程

1. 定义循环结束标记，让run方法结束，因为线程运行代码一般都是循环，只要控制了循环就可以让run方法结束，也就是线程结束。

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

特殊情况：

当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。强制让线程恢复到运行状态，这样就可以操作标记让线程结束。

守护线程

setDaemon(boolean on):将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，java虚拟机退出。该方法必须在启动线程前调用。

守护线程相当于后台线程，前台线程如果结束，后台线程自动结束。

守护线程代码示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

class StopThread implements Runnable

{

private boolean flag =true;//定义布尔型变量，赋初值true

public void run()

{

while(flag)

{

/*

try{

wait();//等待

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

*/

System.out.println(Thread.currentThread().getName()+”….run”);

}

}

public void changeFlag()

{

flag = false;

}

}

class StopThreadDemo

{

public static void main(String[] args)

{

StopThread st = new StopThread();

Thread t1 = new Thread(st);//创建线程
Thread t2 = new Thread(st);

t1.setDaemon(true);//定义守护线程
//t2.setDaemon(true);
t1.start();
t2.start();

int num = 0;
while(true)
{
if(num++ == 60)
{
st.changeFlag();
//t1.interrupt();//停止线程
//t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("over");
}

}

Join与yield方法示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

class Demo implements Runnable

{

public void run()

{

for(int x=0; x<70; x++)

{

//返回该线程的字符串表示形式，包括线程名称、优先级和线程组

System.out.println(Thread.currentThread().toString()+”…..”+x);

Thread.yield();//调用yield()方法释放执行权

}

}

}

class JoinDemo

{

public static void main(String[] args) throws Exception

{

Demo d = new Demo();

Thread t1 = new Thread(d);//创建线程

Thread t2 = new Thread(d);

//t1.join();//这里会有一个异常，可以try或抛

t1.start();

//t1.setPriority(Thread.MAX_PRIORITY);//定义线程优先级
t2.start();
for(int x=0; x<80; x++)
{
//System.out.println("main....."+x);
}
System.out.println("over");
}

}

join方法：等待该线程终止。

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

yield方法：暂停当前正在执行的线程对象，并执行其他线程。

特点：线程一读到Thread.yield();就会释放执行权，临时释放用到。可以稍微减缓一下线程的运行。

优先级

setPriority():更改线程的优先级。

优先级是1—10。

默认优先级是：5。

MAX_PRIORITY:线程可以具有的最高优先级。10

MIN_PRIORITY:线程可以具有的最低优先级。1

NORM_PRIORITY:分配给线程的默认优先级。5

注意：凡是数据是固定的就定义成常量，凡是数据是共享的就定义成静态。

生产者消费者示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

class XianCheng1 {

public static void main(String[] args) {

Ress r = new Ress();

/*

new hread(new Sheng(r)).start();//创建线程并启动线程

new Thread(new Xiao(r)).start();

*/

Sheng s = new Sheng(r);

Xiao x = new Xiao(r);

Thread t1 = new Thread(s); //创建线程
Thread t2 = new Thread(s);
Thread t3 = new Thread(x);
Thread t4 = new Thread(x);

t1.start();//启动线程<p align="left"><span style="color:black;"><span style="font-family:Times New Roman;">                  t2.start();</span></span></p><p align="left"><span style="color:black;"><span style="font-family:Times New Roman;">     t3.start();</span></span></p><p align="left"><span style="color:black;"><span style="font-family:Times New Roman;">     t4
a333
.start();</span></span></p> }

}

class Ress{

private String name;

private int count = 1;

private boolean fa = false;

public synchronized void set(String name){
while(fa)
try {
wait();//等待
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name = name+"---"+count++;//让count自增
System.out.println(Thread.currentThread().getName()+"---生产者--"+this.name);
fa = true;
notifyAll();//唤醒所有
}

public synchronized void out(){
while(!fa)
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"----------消费者--"+this.name);
fa = false;
notifyAll();
}

}

class Sheng implements Runnable{

private Ress r;//定义对象引用

Sheng(Ress r){

this.r = r;

}

public void run() {

while(true)

r.set(“==商品==”);

}

}

class Xiao implements Runnable{

private Ress r;

Xiao(Ress r){

this.r = r;

}

public void run() {

while(true)

r.out();

}

}

对于这个示例我们不可以定义if语句了只能定义while语句，为什么呢？

因为是多个消费者和多个生产者，需要让被唤醒的线程再一次判断标记。

为什么定义notifyAll()？

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

if语句只适用在只有一个生成者和消费者的时候。

这个问题怎么解决呢？

在JDK1.5中提供了多线程升级解决方案

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

将Object中的wait,notify,notifyAll,替换成了Condition对象。

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

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

新特性示例：

[java] view plaincopy在CODE上查看代码片派生到我的代码片

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

//一定要导包，否则有错误

class XianCheng2 {

public static void main(String[] args) {

Ress1 r = new Ress1();

Sheng1 s = new Sheng1(r);
Xiao1 x = new Xiao1(r);

Thread t1 = new Thread(s); //创建线程
Thread t2 = new Thread(s);
Thread t3 = new Thread(x);
Thread t4 = new Thread(x);

t1.start();//启动线程
t2.start();
t3.start();
t4.start();

}

}

class Ress1 {

private String name;

private int count = 1;

private boolean fa = false;

private Lock lock = new ReentrantLock();//创建Lock的实现类对象。
private Condition condition_sheng = lock.newCondition();//新Condition实例。
private Condition condition_xiao = lock.newCondition();

public void set(String name) throws InterruptedException {
lock.lock();//获取锁
try {
while (fa)
condition_sheng.await();//生产者等待
this.name = name + "---" + count++;
System.out.println(Thread.currentThread().getName()+ "---生产者--" + this.name);
fa = true;
condition_xiao.signal();//唤醒消费者
} finally {//一定执行语句
lock.unlock();//释放锁
}
}

public void out() throws InterruptedException {
lock.lock();

try {
while (!fa)
condition_xiao.await();
System.out.println(Thread.currentThread().getName()+ "----------消费者--" + this.name);
fa = false;
condition_sheng.signal();
} finally {
lock.unlock();
}
}

}

class Sheng1 implements Runnable {

private Ress1 r;

Sheng1(Ress1 r) {

this.r = r;

}

public void run() {

while (true)

try {

r.set(“==商品==”);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

class Xiao1 implements Runnable {

private Ress1 r;

Xiao1(Ress1 r) {

this.r = r;

}

public void run() {
while (true)
try {
r.out();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

Lock：它是一个接口，实现提供了比使用synchronized方法和语句可获得的更广泛的锁定操

作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的Condition对象。

ReentrantLock：是Lock的实现类。

Lock:替代了synchronized方法和语句的使用。

lock ():获取锁。

unlock():释放锁。

newCondition():返回绑定到此Lock实例的新Condition实例。

Condition：替代了Object监视器方法的使用(wait notify notifyAll)，它也是一个接口。

await();等待，会抛异常。

signal();唤醒一个等待线程。

signalAll();唤醒所有等待线程。

注意：要把lock.unlock();放到finally里，释放锁的资源。

新特性好处：一个锁上可以有多个相关的Condition。

总结：

run方法是将自定义代码存储的地方，不可以直接调用。

我们在开发时建议使用创建线程的实现Runnable接口方法，因为Java里面只允许单一继承，但允许实现多个接口。实现Runnable接口方法更加灵活。

多线程的安全问题与多线程的随机性有关，解决方法就是同步。

线程在我们不自定义起名时有默认的名称，Thread-编号，该编号从0开始。

finally里一般是用来释放资源的，join就是在要主线程的CPU执行权。Join有加入的意思。

等待和唤醒必须是同一个锁。

——- android培训、java培训、期待与您交流！ ———-