黑马程序员-线程Thread学习笔记

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

Thread 线程

一、创建线程的方法

  1.通过api的查找，java已经提供了对线程这类事务的描述，就是Thread类

   创建线程的第一种方式：继承Thread类 

   步骤：

   1>定义类继承Thread

   2>复写Thread类中的run方法

   3>调用线程的start方法

      该方法的两个作用：启动线程，调用run方法

   

   2实现Runable接口

步骤：

1>定义实现Runnalbe接口

2>覆盖Runnalbe接口中的run方法，将线程要运行的代码存放到run方法中

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

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

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

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

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

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

Class demo implements Runnalbe

{

   public void run()

   {

         for(int i=0;i<100;i++)
             {

         System.out.println(“子线程”+i);

         }

   }


}

Class Demo

{

      public static void main(String[]args)

      {

       demo d=new demo();

       Thread t=new Thread(d);

       t.start();

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

        {

           System.out.println(“主线程”+i);

        }

      }

}

 

二、多线程的同步：

同步的前提：1.必须要有两个或者两个以上的线程2.必须是多个线程使用同一个锁

举例：一个线程从一个Person对象中 设置名字和性别 另一个进程从一个Person对象中取

      得名字和性别。

public class anquan

{

public static void main(String[]args)

{

Person a=new Person ();//建立一个Peron对象a

//new Thread(new in(a)).start();

//new Thread(new out(a)).start();


in b=new in(a);

out c=new out(a);

Thread t1=new Thread(b);

Thread t3=new Thread(c);

t1.start();

t3.start();


}

}

class Person 

{

private  String name;

private  String sex;

public synchronized void setName(String name,String sex)//同步函数  

{

this.name=name;

this.sex=sex;

}

public synchronized void getName()//同步函数

{

System.out.println("name==="+this.name+"======sex====="+this.sex);

}

}

class in implements Runnable

{

private Person a;

in(Person a)

{

this.a=a;

}

boolean b=true;

public void run()

{

while(true)

{

    if(b)

      {

  a.setName("王五","man");

      }

    else

      {

      a.setName("小六","women");


      }

     b=!b;

  }

  

}

}


class out implements Runnable

{

private Person a;

out(Person a)

{

this.a=a;

}

public void run()

{

while(true)

a.getName();

}

}

 

 上述代码中 线程in修改A类的对象中的两个成员，线程out输出A类对象中的两个成员，     

问题1：如何找多线程运行将会产生或者可能产生的同步问题呢?

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

2.明确共享数据

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

问题2：在多线程中同步中到底用的那个锁

1在同步代码块中可以指定 同步所用的锁

2在同步函数中  用的锁为本类对象

3太同步静态函数中 用的锁为本类对应的Class对象

问题3：在什么情况下 ，会有死锁的发生？

如下述代码：两个线程，锁中有锁

package packTread;

class Ticket implements Runnable//extends Thread

{

Object b=new Object();

private  int tick=100;

boolean flag=true;

public void run()

                 {

if(flag)

    {

while(true)

{

synchronized(b)//锁为b

{

show();//锁为this

}

}


    }

else

  while(true)

  show();

                 }

public  synchronized void show()//锁为this

{

synchronized(b)//锁为b

{

if(tick>0)

    {

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

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

    }

}

}


}



public class TicketDemo

{

public static void main(String[]args)

{

Ticket t=new Ticket();

Thread t2=new Thread(t);

Thread t3=new Thread(t);

t2.start();

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

t.flag=false;//

t3.start();

}

}

 

三：综合案例,生产者消费者问题JDK1.5升级版同步处理方式

首先理解一下线程的四种状态

    package percon;

import java.util.concurrent.locks.*;

public class ProducerConsumerDemo

{

public static void main(String[]args)

{

Resource m=new Resource();

/*下面创建两个生产者和两个消费者*/

new Thread(new Producer(m)).start();

new Thread(new Producer(m)).start();

new Thread(new Consumer(m)).start();

new Thread(new Consumer(m)).start();

}

}

class Resource

{

private String name;

private int count=1;

private boolean flag=false;

Lock lock=new ReentrantLock();

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

 将同步Synchronized替换成了Lock操作

 将Object中的wait notify  notifyALL  替换成了Condition对象

 该对象可以Lock锁进行获取

 该实例中，实现了本方只唤醒对方操作  避免了原有版本中唤醒全部线程


*/

Condition pro=lock.newCondition();

Condition con=lock.newCondition();


public void in(String name) throws InterruptedException

{

lock.lock();

try{

while(flag)   pro.await();//while保证每一次唤醒都要判断此标志

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

System.out.println(Thread.currentThread().getName()+"-------"+this.name);



flag=true;

con.signal();

    }

finally

{

lock.unlock();

}


}

public void out(String name) throws InterruptedException

{

lock.lock();

try{

while(!flag) con.await();

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

System.out.println(Thread.currentThread().getName()+"-------"+this.name);


flag=false;

pro.signal();

}


finally

{

lock.unlock();

}

}

}

class Producer implements Runnable

{

private String name="生产者";

private Resource a=new Resource();


Producer(Resource b)

{

a=b;

}

public void run()

{

while(true)

{

try{

a.in(name);

   }

catch(InterruptedException e)

   {

   }

}

}

}

class Consumer  implements Runnable

{

private String name="消费者";

private Resource a=new Resource();

Consumer(Resource b)

{

a=b;

}

public void run()

{

while(true)

{

try{

a.out(name);

   }

catch(InterruptedException e)

   {


   }

}

}

}