黑马程序员---JAVA基础---多线程（八）

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

 

一、进程与线程
  1、进程：是一个正在执行中的程序。每一个进程制定都有一个顺序，该数据就是一个执行路径，或者叫一个控制单元。
  2、线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。
  3、主线程：JVM在启动的时候会有一个进程java.exe，该进程中至少有一个线程在负责java程序的执行，且运行的代码存在与main方法中。该线程称之为主线程。
《扩展》：其实JVM启动不止一个线程，还有负责垃圾回收机制的线程。
  4、线程的五种状态
  （1）开启：被创建；（2）运行状态：有运行资格且具有执行权；（3）临时或阻塞状态：据有运行资格但没有执行权；（4）冻结状态：放弃了执行资格；（5）消亡：stop（）或run（）结束。

二.、创建线程的方式
   1、创建线程的第一种方式——继承Thread类
  步骤：       
（1）定义类继承Thread。
（2）复写Thread类中的run方法。将线程运行的代码存储在run方法，让线程运行。
（3）调用线程的start方法，开启线程。该方法两个作用：启动线程和调用run方法。
练习： 创建两个线程，和主线程交替运行
class Test extends Thread
{
private String name;
Test(String name)
{
this.name = name;
super(name);
}
public void run()
{
for(int x=0; x<60; x++)
{
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
}
}
}

class ThreadTest
{
public static void main(String[] args)
{
Test t1 = new Test("one---");
Test t2 = new Test("two+++");
t1.start();
t2.start();
// t1.run();
// t2.run();
for(int x=0; x<60; x++)
{
System.out.println("main....."+x);
}
}
}
2、.创建线程的第二种方式：实现Runnable接口
  步骤：
        （1）定义类实现Runnable接口。
        （2）覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。
        （3）通过Thread类建立线程对象。
        （4）将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
        （5）调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
  实现方式好处：避免了单继承的局限性。
3、实现方式和继承方式有什么区别？
继承Thread的线程代码存放Thread子类run方法中。
实现Runnable线程代码存在接口的子类的run方法。

三、多线程的安全问题
  1、问题的原因：当多条语句在操作同一个进线程共享数据时，一个线程对多条语句只执行一部分，这一部分还没执行完，另一个线程就参与进来执行，导致了共享数据的错误。
  2、解决办法：对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
  3、Java对于多线程的安全问题提供了专业的解决方式。这就是同步代码块，如下：
synchronized(对象（判断开关）)
{
需要被同步的代码（看那些语句在操作共享数据）
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
  4、同步的前提：
    （1）必须要有两个或者两个以上的线程。
    （2）必须是多个线程使用同一个锁。好处：解决了多线程的安全问题。弊端：多个线程需要判断锁，较为消耗资源。
四、线程间通信
  1、其实就是多个线程在同时操作同一个资源，但是操作的动作不同。
  2、等待唤醒机制 ：wait（）等待、notify（）唤醒、notifyAll（）唤醒全部用在同步中。
  3、为什么这些操作线程的方法要定义Object类中呢？
   因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
  4、JDK1.5 中提供了多线程升级解决方案
将同步Synchronized替换成现实的Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。

例如：线程间通信—生产者消费者
class ProducerConsumerDemo
{
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();
}
}
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。
为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
*/
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
//  t1    t2
public synchronized void set(String name)
{
while(flag)
try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notifyAll();
}
//  t3   t4 
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
this.notifyAll();
}
}

class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.set("+商品+");
}
}
}

class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
res.out();
}
}
}

 

----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net