Java基础——多线程

12、多线程

进程

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

线程：

就是进程中一个独立的控制单元，线程在控制着进程的执行，一个进程中至少有一个线程

Java VM启动的时候会有一个进程java.exe,，该进程至少有一个线程负责java程序的执行。而且这个线程运行的代码在main方法中，该线程称为主线程，其实更细节说明jvm，jvm启动停止不止一个线程，还有负责垃圾回收机制的线程

创建线程，继承Thread类

1、定义类继承Thread

2、复写Thread中的run方法

3、调用线程start方法，该方法有两种作用（启动线程，调用run方法）

package days4;

class Demo extends Thread

{

public void run()

{

for(int i = 0;i<60;i++)

{

System.out.println("thread"+i);

}

}

}

public class Thr1

{

   public static void main(String[]args)

   {

Demo d=new Demo();

     d.start();

     for(int i=0;i<60;i++)

     {

      System.out.println("main"+i);

     }

   }

}

    发现运行结果每次都不同，因为两个线程都在获取CPU的执行权（CPU执行到谁，谁就执行，在某一个时刻只能有一个程序在运行，多核除外），CPU在做着快速的切换，已达到看上去是同时运行的效果。

我们可以形象的把多线程的运行，形容为互相抢夺CPU资源或执行权

这就是多线程一个特性，随机性，谁抢到谁执行

线程运行状态

获取线程对象及名称

Current  Thread（）获取当前线程对象

对象。getName（）获取线程名称

简单的买票示例

package days4;

class Ticket extends Thread

{

  private int tick=20;

  public void run()

  {

  while(tick>0)

  {

  System.out.println(Ticket.currentThread().getName()+"sale"+tick--);

  }

  }

}

public class Ticket1 

{

public static void main(String[]args)

{

Ticket t1=new Ticket();

Ticket t2=new Ticket();

Ticket t3=new Ticket();

Ticket t4=new Ticket();

t1.start();

t2.start();

t3.start();

t4.start();

}

}

简单的卖票程序（代码改进）

实现Runable接口

1、定义类实现Runnable接口

2、覆盖Runnable接口中的run方法（将线程要运行的代码存放在run方法中）

3、通过Thread类建立线程对象

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

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

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

因为自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程执行指定的run方法，就必须明确run方法所属对象

实现方式和继承方式的区别

好处在于实现方式避免了单继承的局限性。在定义线程时建议实现方式使用实现方式

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

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

package days4;

class Ticket extends Thread

{

  private int tick=20;

  public void run()

  {

  while(tick>0)

  {

  System.out.println(Ticket.currentThread().getName()+"sale"+tick--);

  }

  }

}

public class Ticket1 

{

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

}

}

多线程的安全问题

问题在于当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据错误

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

Java对于多线程的安全问题提供了专业的解决方式——同步代码块

Synchronized（对象）

{

   需要被同步执行的代码块

   

}

对象如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程，即使获取CPU的执行权也进不去，因为没有锁

同步的前提：

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

2、必须多个线程使用同一个锁

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

    

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

弊端：解决了问题但是消耗了资源，多个线程需要判断锁

class Tickets implements Runnable

{

  private int tick=100;

  private Object obj=new Object();

  public void run()

  {

while(true)

{  synchronized(obj)

 { if(tick>0)

  {

  System.out.println(Ticket.currentThread().getName()+"sale"+tick--);

  }

 }

}

 }

}

public class Ticket2 

{

public static void main(String[]args)

{

Tickets t=new Tickets();

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

}

}

多线程同步函数

   练习代码

需求：

银行有一个金库。

有两个储户分别存300员，每次存100，存3次。

目的：该程序是否有安全问题，如果有，如何解决？

如何找问题：

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

2，明确共享数据。

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

package days4;

class Ban

{

private int sum=0;

public synchronized void add(int n)

{

sum=sum+n;

System.out.println("sum="+sum);

}

}

class Cus  implements Runnable 

{

Ban ba;

Cus()

{

 ba=new Ban();

}

    

public void run() 

{

for(int i=0;i<3;i++)

{

   ba.add(100);

}

}

}

public class Bank 

{

public static void main(String[]args)

{

Cus t=new Cus();

Thread t1=new Thread(t);

Thread t2=new Thread(t);

t1.start();

t2.start();

}

}

同步函数——锁

函数需要被对象调用，那么函数都有一个所属对象调用——this，所以同步函数调用的锁是this

package days4;

class Ticket5 implements Runnable

{

private  int tick = 100;

Object obj = new Object();

boolean flag = true;

public  void run()

{

if(flag)

{

while(true)

{

synchronized(this)

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);

}

}

}

}

else

while(true)

show();

}

public synchronized void show()//this

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);

}

}

}

class  This

{

public static void main(String[] args) 

{

Ticket5 t = new Ticket5();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(Exception e){}

t.flag = false;

t2.start();

}

}

静态同步函数的锁是class

通过验证，发现不再是this，因为静态方法中不可以定义this，静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象

类名。Class是锁，该对象类型是class

练习代码：

package days4;

class Ticket6 implements Runnable

{

private static  int tick = 100;

//Object obj = new Object();

boolean flag = true;

public  void run()

{

if(flag)

{

while(true)

{

synchronized(Ticket.class)

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);

}

}

}

}

else

while(true)

show();

}

public static synchronized void show()

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);

}

}

}

class  Static

{

public static void main(String[] args) 

{

Ticket6 t = new Ticket6();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(Exception e){}

t.flag = false;

t2.start();

}

}

多线程——死锁

练习代码：

死锁：

package days4;

class Ticket7 implements Runnable

{

private  int tick = 100;

Object obj = new Object();

boolean flag = true;

public  void run()

{

if(flag)

{

while(true)

{

synchronized(obj)

{

show();

}

}

}

else

while(true)

show();

}

public synchronized void show()//this

{

synchronized(obj)

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);

}

}

}

}

class  Dead

{

public static void main(String[] args) 

{

Ticket7 t = new Ticket7();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(Exception e){}

t.flag = false;

t2.start();

}

}

死锁练习：

package days4;

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

{

static Object locka = new Object();

static Object lockb = new Object();

}

class  Dead2

{

public static void main(String[] args) 

{

Thread t1 = new Thread(new Test(true));

Thread t2 = new Thread(new Test(false));

t1.start();

t2.start();

}

}

线程间通信

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

等待唤醒机制

Wait

Notify

Notifyall( )

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

     因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

练习代码：

package days5;

class Res

{

String name;

boolean flag=false;

int age;

int x=20;

}

class Thr1 implements Runnable

{

private Res r;

Thr1(Res r)

{

this.r=r;

}

 

public void run() 

{

  while(true&&r.x>0)

   {

   synchronized(r)

   {

 if(r.flag)

 {

 try{r.wait();}

 catch(Exception e)

 {

 

 }

 }

  if(r.x%2==0)

 { r.age=5;

   r.name="Tom";

 }

 else

 {

 r.age=10;

 r.name="Anna";

 }

  r.x--;

      r.flag=true;

      r.notify();

   }

   }

}

}

class Thr2 implements Runnable

{

   private Res r;

   Thr2(Res r)

   {

   this.r=r;

   }

public void run() 

{

while(true&&r.x>0)

{

synchronized(r)

{

if(!r.flag)

{

try{r.wait();}

catch(Exception e)

{   }

}

System.out.println("name"+r.name+"age"+r.age);

r.flag=false;

r.notify();

}

}

}

}

public class Wait 

{

public static void main(String args[])

{

Res r2=new Res();

Thr1 th1=new Thr1(r2);

Thr2 th2=new Thr2(r2);

Thread t1=new Thread(th1);

Thread t2=new Thread(th2);

t1.start();

t2.start();

}   

}

package days5;

class Res2

{

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 Res2 r ;

Input(Res2 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 Res2 r ;

Output(Res2 r)

{

this.r = r;

}

public void run()

{

while(true)

{

r.out();

}

}

}

class  Wait2

{

public static void main(String[] args) 

{

Res2 r = new Res2();

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

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

}

}

package days5;

class Res3

{

private String name;

private int age;

boolean flag=false;

int count=20;

public synchronized void Set()

{

    if(flag)

    {

       try{

        this.wait();

       }

       catch(Exception e)

       {

        

       }

    }

if(count%2==0)

{

name="S1";

age=5;

}

else

{

name="S2";

age=10;

}

flag=true;

this.notifyAll();

}

    public synchronized void Out()

    {

     if(!flag)

     {

     try

     {

     this.wait();

     }

     catch(Exception e)

     {

    

     }

     }

     System.out.println(Thread.currentThread().getName()+"name"+name+"age"+age+"%%%%%"+count--);

     flag=false;

     this.notifyAll();

    }

}

class  Input2 implements Runnable

{

    private Res3 r;

    Input2(Res3 r)

    {

     this.r=r;

    }

public void run() 

{

     while(true&&r.count>0)

     {

      r.Set();

     }

}

}

class Output2 implements Runnable

{

private Res3 r;

Output2(Res3 r)

{

this.r=r;

}

public void run()

{

while(true&&r.count>0)

{

r.Out();

}

}

}

public class InputOutput 

{

   public static void main(String []args)

   {

   Res3 re=new Res3();

   Input2 in=new Input2(re);

   Output2 out=new Output2(re);

   Thread t1=new Thread(in);

   Thread t2=new Thread(in);

   Thread t3=new Thread(out);

   Thread t4=new Thread(out);

   t1.start();

   t2.start();

   t3.start();

   t4.start();

   }

}

对于多个生产者和消费者。

为什么要定义while判断标记。

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

为什么定义notifyAll，

因为需要唤醒对方线程。

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

    JDK1.5 中提供了多线程升级解决方案。将同步Synchronized替换成现实Lock操作。

将Object中的wait，notify notifyAll，替换了Condition对象。该对象可以Lock锁 进行获取。该示例中，实现了本方只唤醒对方操作。

Lock替代了Synchronized

Condition：替代了Object wait notify notifyAll

package days5;

import java.util.concurrent.locks.*;

class Resource

{

private String name;

private int count = 1;

private boolean flag = false;

//  t1    t2

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();//t1,t2

this.name = name+"--"+count++;

System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);

flag = true;

condition_con.signal();

}

finally

{

lock.unlock();//释放锁的动作一定要执行。

}

}

//  t3   t4  

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)

{

}

}

}

}

class InputOutput2 

{

public static void main(String[] args) 

{

Resource r = new Resource();

Producer pro = new Producer(r);

Consumer con = new Consumer(r);

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

}

}

停止线程

1、定义循环结束标记

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

2、使用interrupt（中断）方法

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

如何停止线程？

Run方法结束，开启线程运行，运行代码通常都是循环结构，只要控制循环，就可以让run方法结束，也就是循环结束，线程结束

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

Thread类中提供该方法：interrupt（）

Join方法

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

练习代码：

package days5;

class Demo implements Runnable

{

public void run()

{

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

{

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

Thread.yield();

}

}

}

class  Join

{

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

{

Demo d = new Demo();

Thread t1 = new Thread(d);

Thread t2 = new Thread(d);

t1.start();

//t1.setPriority(Thread.MAX_PRIORITY);

t2.start();

//t1.join();

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

{

//System.out.println("main....."+x);

}

System.out.println("over");

}

}