关闭

Java基础日记———多线程

标签: 程序员多线程
219人阅读 评论(0) 收藏 举报
分类:
一.概述   
进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程。
   线程(Thread):同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小。
   线程和进程一样分为五个阶段:创建、就绪、运行、阻塞、终止。
  多进程是指操作系统能同时运行多个任务(程序)。
  多线程是指在同一程序中有多个顺序流在执行。
二.多线程体系
1.线程的创建方式:
第一种方式:实现Runnable接口,复写run()方法,启动是:new Thread(this).start()。
步骤: ①.定义类实现Runnable接口;    
      ②.覆盖Runnable接口的run方法。
      ③.通过Thread类建立线程对象。
      ④.将Runnable接口的子类对象作为实际参数传递给Thread类的构造
          因为自定义的run方法所属的对象是Runnable接口的子类对象。
          所以要让线程去指定对象的run方法,就必须明确run方法所属的对象。
      ⑤通过Thread类的start方法开启线程并且调用Runnable接口子类的run方法。

代码示例:

 public class ThreadTest1 {
    public static void main(String[] args) {
            Runnable1 r = new Runnable1();
            //r.run();并不是线程开启,而是简单的方法调用
            Thread t = new Thread(r);//创建线程
            //t.run(); //如果该线程是使用独立的 Runnable 运行对象构造的,则调用Runnable 对象的 run 方法;否则,该方法不执行任何操作并返回。
            t.start(); //线程开启
            for (int i = 0; i < 100; i++) {
                System.out.println("main:"+i);
            }
        }
    }
    class Runnable1 implements Runnable{
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread-----:"+i);
            }
        }
    }
    第二种方式:继承Thread,复写run()方法,之后调用start的方法:启动线程,调用run方法。如果直接调用run方法,不会开启新线程。
步骤:

代码示例:

 class Demo extends Thread
    {
         public void run()
         {
              for(int x=0; x<60; x++)
               System.out.println("demo run----"+x);
         }
    }
    class ThreadDemo
    {
         public static void main(String[] args)
         {
          Demo d = new Demo();//创建好一个线程。
          d.start();//开启线程并执行该线程的run方法。
          //d.run();//仅仅是对象调用方法。而线程创建了,并没有运行。
          for(int x=0; x<60; x++)
           System.out.println("Hello World!--"+x);
         }
    }
解析:发现运行结果每一次都不同。
    因为多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。
    明确一点,在某一个时刻,只能有一个程序在运行。(多核除外)
    cpu在做着快速的切换,以达到看上去是同时运行的效果。
    我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
    这就是多线程的一个特性:随机性。谁抢到谁执行,至于执行多长,cpu说的算。

小结:现接口可以实现多个接口,但是继承只能有一个父类。所以,实现接口,较好。


2.线程的运行状态:
    一个线程有五种状态:被创建,运行状态,冻结状态,消亡,阻塞状态。
它们之间的转换如下图:

3.安全问题
    多线程操作可能不同的线程对同一数据进行操作,那样的话数据的值会出现安全问题。这就需要使对共享数据部分也就是共同操作部分进行限制:某段时间内只可以一个线程进行操作,也就是线程的同步。
(1)同步代码块
问题的原因:
     当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完, 另一个线程参与进来执行。导致共享数据的错误。 
解决办法:
     对多条操作共享数据的语句,只能让一个线程都执行完。在执行过程中,其他线程不可以参与执行。
    Java对于多线程的安全问题提供了专业的解决方式。
    就是同步代码块。 
    synchronized(对象)
    {
         需要被同步的代码
    }
    对象如同锁。持有锁的线程可以在同步中执行。
    没有持有锁的线程即使获取cpu的执行权,也进不去,因为没有获取锁。
优缺点:
    同步的前提:
    ①必须要有两个或者两个以上的线程。
    ②必须是多个线程使用同一个锁。
    必须保证同步中只能有一个线程在运行。
    好处:解决了多线程的安全问题。
    弊端:多个线程需要判断锁,较为消耗资源,

代码示例:卖票

 class Ticket implements Runnable
    {    private  int tick = 1000; 
         Object obj = new Object();
         public void run()
     {
          while(true)
      {
           synchronized(obj)
       {
            if(tick>0)
        {
             System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
        }   }   }  }  } 
class  TicketDemo2
{
 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();
    } 
}
(2)同步函数
    同步函数用的是哪一个锁呢?
    函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
    所以同步函数使用的锁是this。
程序验证同步函数的锁为this。
    使用两个线程来买票,即上面的例子进行修改 。
    一个线程在同步代码块中。
    一个线程在同步函数中。
    都在执行买票动作。

代码示例:

  public synchronized void show()//this
     {
          if(tick>0)
      {
           System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
          }
     }
(3)同步函数被静态修饰
    通过验证,发现不在是this。因为静态方法中也不可以定义this。
    静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
    类名.class  该对象的类型是Class
    静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
特例:
    单例设计模式:解决一个类在内存中只存在一个对象。
单例步骤:  
    ①将构造函数私有化。
    ②在本类中创建一个本类对象(私有并且static)。
    ③提供一个方法可以获取到该类对象。

单例分为:饿汉式和懒汉式
饿汉式:单例模式一般用

    private static final Single s = new Single();
        private Single(){}
         public static Single getInstance()
         {
              return s;
         }

懒汉式:加上锁以后比较低效(没个线程都要访问判断锁)
特点:延迟加载,但是当多线程是有安全问题。可以使用加同步来解决,并且加双层判断来提高效率。
其中锁为Class锁。

     private static Single s = null;
         private Single(){}
         public static  Single getInstance()
         {
                  if(s==null)
          {
           synchronized(Single.class)
               {
                    if(s==null)
                     //--->A;
                     s = new Single();
               }
          }
          return s;
     }
4.线程间的通讯
    其实就是多个线程在操作同一个资源,
    但是操作的动作不同。而且需要同步的代码在两个类中时就容易出现问题。
解决方法:
(1)使共享操作部分称为同步代码
(2)等待唤醒机制
    wait:
    notify();
    notifyAll();
都使用在同步中,因为要对持有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁。
 为什么这些操作线程的方法要定义Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程只有的锁,
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。
例子:
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify notifyAll,替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中,实现了本方只唤醒对方操作。
Lock:替代了Synchronized
     lock
     unlock
     newCondition()
Condition:替代了Object wait notify notifyAll
     await();
     signal();
     signalAll();

例子:生产者消费者

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

JDK15升级版:
    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)
   {
   }
  }
 }
}
5.其他方法摘要
(1)stop()方法已经过时。
    如何停止线程? 
    只有一种,run方法结束。
    开启多线程运行,运行代码通常是循环结构。
    只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:
    当线程处于了冻结状态。
    就不会读取到标记。那么线程就不会结束。

   当没有指定的方式让冻结的线程恢复到运行状态是,这时需要对冻结进行清除。 
    强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

   Thread类提供该方法 interrupt();
    将处于阻塞等待状态的线程中断。
     Thread.interrupt()方法不会中断一个正在运行的线程。这一方法实际上完成的是,在线程受到阻塞时抛出一个中断信号,这样线程就得以退出阻塞的状态。更确切的说,如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞,那么,它将接收到一个中断异常(InterruptedException),从而提早地终结被阻塞状态。
     因此,如果线程被上述几种方法阻塞,正确的停止线程方式是设置共享变量,并调用interrupt()(注意变量应该先设置)。如果线程没有被阻塞,这时调用interrupt()将不起作用;否则,线程就将得到异常(该线程必须事先预备好处理此状况),接着逃离阻塞状态。在任何一种情况中,最后线程都将检查共享变量然后再停止。

代码示例:

     t.Interrupt();//t为一个线程。
(2)守护线程
    setDaemon(boolean on) 将该线程标记为守护线程或用户线程.当正在运行的线程都是守护线程时,Java 虚拟机退出。
    也就是说:当其他非守护线程都结束了它(它们)才结束。
(3)join() :等待该线程终止。
    当A线程执行到了B 线程的。join()方法时,A就会等待。等B线程都执行完,A才会执行。
     join可以用来临时加入线程执行。主线程遇到Join后会等待使他等待的那个线程完成后再执行。
    优先级:谁开启的该线程,那么该线程属于哪个线程组。
    线程优先级分十级。越高抢到CPU执行权的概率更大,但是其他线程不会不执行。
(4)yield() : 暂停当前正在执行的线程对象,并执行其他线程。
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:2342次
    • 积分:151
    • 等级:
    • 排名:千里之外
    • 原创:13篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章分类
    文章存档