Java基础---多线程

多线程的概念，如何在程序中创建多线程(Thread、Runnable)，线程安全问题，线程的同步，线程之间的通讯、死锁。

一、 创建线程和启动线程。

为什么要覆盖run方法：Thread类用于描述线程。

该类就定义了一个功能。用于存储线程要执行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法。用于存储线程要运行的代码。

创建线程的两种方法中，实现Ruunable接口可以避免单继承的局限性。

启动线程d1.run(); t1.start();run和start的区别：d1.run();就开始执行run方法中的代码了。

start方法是：启动线程，调用run方法。

二 线程的安全机制

线程安全问题都是由全局变量及静态变量引起的。当一个线程在运行时，

另一个线程进来并改变了当前线程运算需要用到的变量的值，这就会导致当前线程计算出错，

这就是线程的不安全。

为了提高多线程安全性，解决方法有同步代码块和同步函数。

同步的前提：

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

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

利弊：

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

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

代码实例：

<span style="font-size:14px;">package Thread;

/**
* @author Administrator
*创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。
*		该子类应重写 Thread 类的 run 方法。
*
*另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。
*
*
*将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
*/
public class ThreadBandTest {

public static void main(String[] args) {
//第1种继承Thread,并复写run方法。
Demo d1 = new Demo();
Demo d2 = new Demo();
d1.run();
d2.run();

//第2种实现Runnable接口。
Cus c = new Cus();
//开启两个储户线程
Thread t1 = new Thread(c);
Thread t2= new Thread(c);

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

}

/*
* 同步的两种表达方式
1，同步代码块
2，同步函数
* */
//创建银行类
class Bank{
//储户存入总和
private int sum;

//同步函数，为两个储户线程共享的代码（数据）
/*public synchronized void add(int n){
sum=sum+n;
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("sum= "+sum);
}*/
//同步代码块实现线程的代码共享
Object obj = new Object();
public void add(int n){
synchronized (obj) {
sum = sum+n;
try {
Thread.sleep(500);
} catch (Exception e) {
// TODO: handle exception
}
System.out.println("sum = "+sum);
}
}

}

//继承Thread
class Demo extends Thread{
public void run(){
for(int i=0;i<8000;i++)
System.out.println(i);
}
}

//创建储户类   实现Runnable接口
class Cus implements Runnable{
private Bank b = new Bank();
//实现每个储户存储三次，每次100
public void run(){
for(int x=0;x<3;x++){
b.add(100);
}
}
}
</span>

三 线程之间的通讯

线程之间通讯：其实就是多个线程在操作同一个资源。但是操作的动作不同。用到的方法如下：

wait();当前线程处于等待状态，直到有notify将其唤醒。

notify();唤醒一个线程池中持有同样锁的等待线程，通常唤醒第一个被等待的线程。

notifyall();唤醒线程池中所有的等待

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

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

因为这些方法在操作同步中线程时，都必须要标识他们所操作线程持有的锁只有同一个锁上的被等待线程，

可以被同一个锁上的notify唤醒。不可以对不同锁中的线程进行唤醒。

也就是说等待跟唤醒必须是同一把锁

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

示例代码：

演示两个线程操作同一个资源，但是动作不同，将两个动作的代码块都进行同步，并且使用同一把锁，

但是存在动作一或者动作二一直持有执行权和执行资格，为了实现存入和输出交替进行，加入了wait()和notify方法，

输入和输出通过判断标志flag的真假，交替进行。

但是存在同步嵌套的情况，这时同步所用的锁不同，这样就导致在执行wait和notify的时候具体等待或者唤醒哪个线程

不明确，所以要标识锁，如r.wait(); r.notify(); 唤醒的是持有r这把锁的同步代码块中的线程，

1.动作一，存入信息

<span style="font-size:14px;">synchronized(r)
{
if(r.flag)  //初始为假  存入信息
//存入信息线程判断true则等待被唤醒，false则执行存入
try{r.wait();}catch(Exception e){}
if(x==0)
{
r.name="mike";
r.sex="man";
}
else
{
r.name="丽丽";
r.sex="女女女女女";
}
x=(x+1)%2;
r.flag=true;//存完以后置为真，此时存入线程判断为真，执行等待。
r.notify();//唤醒输出信息线程
}</span>

2.动作二，输出信息。

<span style="font-size:14px;">synchronized(r)
{
//判断为true则输出，false则等待
if(!r.flag)//非真为假，不执行等待
try{r.wait();}catch(Exception e){}
System.out.println(r.name+"****"+r.sex);
r.flag=false;//打印一次将标志置为假，输出线程再次判断非假为真，等待被唤醒。
r.notify();//唤醒存入线程
}</span>

注意：对于非静态同步函数来说。它的锁是this,this.wait(); this.notify();

<span style="font-size:14px;">public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){}

this.name=name;
this.sex=sex;

flag=true;
this.notify();
}
</span>

线程之间通讯示例代码：

<span style="font-size:14px;">class Res  //定义一个共同操作的资源，即共享数据
{
private String name;
private String sex;
private boolean flag=false;//初始为假

public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){}

this.name=name;
this.sex=sex;

flag=true;
this.notify();
}
public synchronized void out()
{
if(!flag)

try{this.wait();}catch(Exception e){}

System.out.println(name+"****"+sex);

flag=false;

this.notify();
}
}

class Input implements Runnable   //输入方法
{
private Res r;
Input(Res r)
{
this.r=r;
}
public void run()
{
int x=0;
while(true)
{

if(x==0)
r.set("mike","man");
else
r.set("丽丽","女女女女女");

x=(x+1)%2;
}
}
}

class Output implements Runnable//输出方法
{
private Res r;
Output(Res r)
{
this.r=r;
}
public void run()
{
while(true)
{
r.out();
}
}
}

class  InputOutputDemo2
{
public static void main(String[] args)
{
Res r=new Res();  //创建一个对象

new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/*
Input in=new Input(r);
Output out=new Output(r);

Thread t1=new Thread(in);//建立线程
Thread t2=new Thread(out);

t1.start();//打开线程
t2.start();
*/
}
}
</span>

四 、线程停止

如何停止线程？

* 让run方法结束，即控制循环结束，但是存在特殊情况：当线程处于冻结状态，就不会读到结束标志，线程就不会结束。

*这时就要对冻结状态进行清除，让线程恢复到运行状态，这样就可以操作标记让线程结束。

*Thread类中提供了该 方法：interrupt();方法。

代码实例：

<span style="font-size:14px;">class StopThreadDemo {

public static void main(String[] args) {
StopThread st = new StopThread();

//创建两个线程并开启。
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);

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

//同时开启一个主线程。
int num = 0;
while(true){
if(num++ ==60){
//主线程运行结束，此时t1  t2两个线程处于冻结状态，
//st.changeFlag();
t1.interrupt();//使用interrupt()方法对冻结状态进行清除。
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"****main****run"+num);
}
}

}

class StopThread implements Runnable{
private boolean flag = true;
public synchronized void run(){
while(flag)
{
try {
wait();//线程t1  t2一进来就等待，即冻结状态。
} catch (InterruptedException e) {
//当执行t1 t2冻结状态清除时，发生中断异常，可以在这里将标志置为false，结束这两个线程。
// TODO: handle exception
System.out.println(Thread.currentThread().getName()+"****Exception");
flag = false;
}
System.out.println(Thread.currentThread().getName()+"******run");
}
}
public void changeFlag(){
flag = false;
}
}</span>

五 、多线程中的单例设计模式

懒汉式 多线程访问时出现安全问题 采用同步函数效率低下（加的锁是该类所属的字节码文件对象 类名.class）

代码实例：

<span style="font-size:14px;">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();
return s;
}
}
}
}</span>

六 、死锁

造成死锁的原因：同步中嵌套同步，而锁不同。我们在程序设计时要尽量避免死锁这种情况的出现。

示例代码：

<span style="font-size:14px;">package Thread;

public class DeadLockDemo {

public static void main(String[] args) {
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));

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

class Test implements Runnable{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run(){
if(flag)
{
//在持有locka锁的同步代码块中嵌套了持有lockb锁的同步块，
synchronized (MyLock.locka) {
System.out.println("if *** locka");
synchronized (MyLock.lockb) {
System.out.println("if ***lockb");
}
}
}
else
{
//在持有lockb锁的同步代码块中嵌套了持有locka锁的同步块，
synchronized (MyLock.lockb) {
System.out.println("else######lockb");
synchronized (MyLock.locka) {
System.out.println("else######locka");
}
}
}
}

}

class MyLock{//存储两个锁。
static Object locka = new Object();
static Object lockb = new Object();
}</span>