关于多线程

经过了两天的学习，多线程算是模模糊糊的了解了不少，虽然中间还有很多东西还不懂，但也想写下博客，总结一下知识，顺便帮助一下可能需要到这些的人~

一、多线程

1）、进程：

进程就是一个正在执行中的程序，没一个进程执行都有一个执行顺序，改顺序是一个执行路径，或者叫一个控制单元

2）、线程：

县城就是进程中的一个独立的控制单元，线程在控制着进程的执行。

JVM(java vrtual machine)在启动的时候就会有一个进程java.exe。该进程中至少有一个线程负责java程序内部的执行。而这个线程运行的代码存在于mian方法 中，所 以，该线程又称之为主线程。

扩展：在JVM(java virtual machine)启动的时候就不止一个线程了，出了一个主线称(main)之外，还有负责垃圾回收机制的线程

二、创建线程

1）、通过查阅API，我们发现，创建一个线程有两种方法

a）、

通过extends  Thread类

b）、

通过implements Runnable接口

两种方式的区别：

extends：线程代码存放Thread子类的run方法中

implements：线程代码存在与接口的子类的run方法中

建议：在创建线程时，建议使用implements方法，可以避免单继承的局限性。

三、线程安全问题

1）、原因：

当多个线程在操作共享数据是，一个线程对多条语句只执行了一部分，还没有执行完，就被另一个线程抢走了执行权，这就会导致共享数据的错误。

2）、解决办法：

当线程操作贡献数据的时候，我们需要让一个线程执行完，在该线程执行的时候，其他线程不可以参与进来。

（java对于多线程的安全问题提供了专业的解决方法）

a)、同步代码块：

synchronized(Object obj）

{

需要被同步的代码

}

注：我们这里的Object如同一个锁，持有锁的线程可以在同步中执行，没有持有锁的线程即使获取了cpu的执行权，也进不去。

在同步代码块中，锁可以是任意对象

同步方法：

可以在方法的声明中加上synchronized修饰，使该方法变为同步方法

同步代码块的锁可以是任意对象，那么同步方法的锁又是谁呢？

一个方法需要被对象调用，在一个方法中都有一个所属对象的引用：this。

在同步方法中，锁是this

静态同步方法：

当一个同步方法被static修饰后，方法中是不可能有对象，更不可能有对象的引用this了

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

在静态同步方法中：锁匙类名.class

b）、同步的前提：

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

2，多个线程的所必须是同一个锁

3，必须保证同步中至少有一个线程在运行

c）、同步的优缺

优点：解决了多线程的安全问题

缺点：多个线程必须要先判断锁，较为消耗资源，降低了效率

3）、如何找到问题：

1、明确那些代码是多线程运行代码

2、明确共享数据

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

四、同步升级

在jdk1.5，提供了多线程升级解决方案

将同步：synchronized替换成了Lock操作

将Object中的wait()、notify()、notifyAll()替换成了condition对象（该对象可以通过Lock获取，可以完成唤醒对方的操作）

/*
复习总结今天所学过的东西
*/
package day03;
import java.util.concurrent.locks.*;
class TheLastStorehouse
{
/*
一个人的属性（Attributes）
姓名：name
性别：gender
年龄：age
*/
private String name;
private String gender;
private int age;


/*
上锁，解锁，Upgrade版的synchronized
定义了三个为实现等待唤醒机制的condition
*/
private final Lock lock = new ReentrantLock();
private Condition condition_1 = lock.newCondition();
private Condition condition_2 = lock.newCondition();
private Condition condition_3 = lock.newCondition();
/*
flag1：确保三个线程逐一执行，不会出现一个线程连续执行多次的情况
flag2：确保三个线程按一定的顺序来执行
*/
private boolean flag1 = false;
private boolean flag2 = true;


/*
对一个人的属性进行赋值，在赋完值之后，是该线程wait，并唤醒下一个线程
*/
public void setAttributes(String name, String gender,int age) throws InterruptedException
{
lock.lock(); // 上锁
try
{
while(flag1)
condition_1.await();  // 在使用condition_1.await();如果interrupted该线程，会抛出异常
this.name = name;
this.gender = gender;
this.age = age;
System.out.println(/*Thread.currentThread().toString() + */"<-->" 
+ "\nname:" + name + " gender:" + gender + " age:" + age);
flag1 = true;
condition_2.signal();  // 唤醒打印该人的属性的线程
}
finally
{
lock.unlock();  //  解锁
}
}
/*
打印之前所赋过值得人的属性，其他同上
*/
public void PrintAll() throws InterruptedException
{
lock.lock();
try
{
while(!flag1)
condition_2.await();
System.out.println(/*Thread.currentThread().toString() + */">>>" + name);
flag1 = false;
flag2 = false;
condition_3.signal();
}
finally
{
lock.unlock();
}
}
/*
判断该人的性别和年龄，若是male：男人，female：女人
若age<=18:Keep_Going; 若>18:I'll keep going
*/
public void judgment() throws InterruptedException
{
lock.lock();
try
{
while(flag2)
condition_3.await();
if(gender.equals("male"))
System.out.print("男人");
else if(gender.equals("female"))
System.out.print("女人");


if(age<=18)
System.out.println("KeepGoing");
else
System.out.println("I'll keep going");
flag2 = true;
condition_1.signal();
}
finally
{
lock.unlock();
}
}
}




/*
实现Runnable接口，重写run方法，
这个人一共有两种属性，轮流切换
1）、邵子鑫，male，17
2）、安安，female，20
*/
class InputAttributes implements Runnable
{
private TheLastStorehouse tls;


InputAttributes(TheLastStorehouse tls)
{
this.tls = tls;
}


public void run()
{
int x = 1;
try
{
while(true)
{
if(x == 1)
tls.setAttributes("邵子鑫","male",17);
else
tls.setAttributes("安安","female",20);
x = (x+1)%2;
}
}
catch (InterruptedException e)
{
}
}
}


/*


*/
class OutputAttributes implements Runnable
{
private TheLastStorehouse tls;


OutputAttributes(TheLastStorehouse tls)
{
this.tls = tls;
}


public void run()
{
try
{
while(true)
tls.PrintAll();
}
catch (InterruptedException e)
{
}
}
}


class JudgAttributes implements Runnable
{
private TheLastStorehouse tls;


JudgAttributes(TheLastStorehouse tls)
{
this.tls = tls;
}
public void run()
{
try
{
while(true)
tls.judgment();
}
catch (InterruptedException e)
{
}
}
}


public class TheLastDemo
{
public static void main(String[] args)
{
TheLastStorehouse tls = new TheLastStorehouse();

InputAttributes in = new InputAttributes(tls);
OutputAttributes out = new OutputAttributes(tls);
JudgAttributes judg = new JudgAttributes(tls);


Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
Thread t3 = new Thread(judg);


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

}