线程2

最新推荐文章于 2023-06-26 16:59:16 发布

xdajian

最新推荐文章于 2023-06-26 16:59:16 发布

阅读量103

点赞数

分类专栏： Java 文章标签： thread C C++ C#

本文链接：https://blog.csdn.net/xdajian/article/details/83844140

版权

Java 专栏收录该内容

35 篇文章 0 订阅

订阅专栏

>>3内部class类继承Thread的线程实现方式
public class TestThread
{
public static void main(String[] args)
{
  //实现Runnable接口得线程实现方式用与和内部类比较
  MyThread myt1 = new MyThread();
  //new Thread(myt).start()的理解：根据myt对象，实例化一个线程对象，并开始线程
  new Thread(myt1).start();
//内部类继承Thread类的线程实现方式
  MyThread2 myt = new MyThread2();
  //由于内部类继承Thread类，所以可以使用start方法，但是方式很特别
  myt.new InnerThread().getThread().start();
  System.out.println("main方法线程名字："+Thread.currentThread().getName());
}
}
//实现Runnable接口的实现线程的方法
class MyThread implements Runnable
{
public void run()
{
  System.out.println("实现Runnable接口子线程得名字："+Thread.currentThread().getName());
}
}
//内部类继承Thread类  实现线程赞成频繁使用
class MyThread2
{
//定义内部类：1内部类继承Thread类或实现Runnable接口，覆盖run方法  2提供一个返回值是Thread的方法，返回内部类的对象 class InnerThread extends Thread
{
  public void run()
  {
    System.out.println("内部类输出线程名称:"+Thread.currentThread().getName());
  }
}
//返回值为线程类型的方法实例化并返回内部类（内部类实现线程的关键）Thread getThread()
public Thread getThread
{
  return new InnerThread();
}
}
>>4线程同步(synchronized)得实现：同步块和同步方法
public class TestThread
{
public static void main(String[] args)
{
  //四个线程同时销售100张票
  //同步块实现售票
  //SellThread myt = new SellThread();
  //new Thread(myt).start();//开启第一个窗口开始售票即开启一个线程对同步对象惊醒操作实现了共享数据同步操作
  //new Thread(myt).start();//开启第二个窗口开始售票即开启一个线程对同步对象惊醒操作
  //new Thread(myt).start();//开启第三个窗口开始售票即开启一个线程对同步对象惊醒操作
  //new Thread(myt).start();//开启第四个窗口开始售票即开启一个线程对同步对象惊醒操作

//同步方法实现售票
  SellThread1 myt1 = new SellThread1();
  new Thread(myt1).start();//开启第一个窗口开始售票
  new Thread(myt1).start();//开启第二个窗口开始售票
  new Thread(myt1).start();//开启第三个窗口开始售票
  new Thread(myt1).start();//开启第四个窗口开始售票

}
}
//同步块对某一个对象Ojbect进行加锁
class SellThread implements Runnable
{
int tickets= 100;//100张票
Object obj =  new Object();//同步变量
public void run()
{
  while(true)
  {
//给obj对象加锁，直到同步块结束，“{”表示给obj对象加锁，"}"表示给obj对象解锁
   synchronized(obj)
{
    if(tickets>0)
    {
//sleep是Thread类的静态方法，调用时会抛出异常，需要捕获。
     try{
      Thread.sleep(10);
     }catch(Exception e)
     {
      e.printStackTrace();
     }
     System.out.println("线程："+Thread.currentThread().getName()+"sell==="+tickets);
     tickets--;
    }
   }
/*错误的方法：先锁住对象，在while循环，最终只走一个线程(与上边对比：先while再synchronized)
//同步块
synchronized(this)
{
while(tickets>0)
   {
    try{
     Thread.sleep(1000);
    }
    catch(Exception e)
    {
     e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName()+"sells tickets==="+tickets);
    tickets--;
   }
  }
*/
  }
}
}

//同步方法对this加锁
class  SellThread1 implements Runnable
{
int tickets= 100;//100张票
//run方法调用同步方法sell
public void run()
{
  sell();
}
//声明同步方法的关键字：synchronized
public synchronized void sell()
{
  while(true)
  {
    if(tickets>0)
    {
     try{
      Thread.sleep(10);
     }catch(Exception e)
     {
      e.printStackTrace();
     }
     System.out.println("线程："+Thread.currentThread().getName()+"sell==="+tickets);
     tickets--;
    }
  }
}
}

>>5 同步块和同步方法实现共享数据的同步
public class TestThread
{
public static void main(String[] args)
{
//同步块和同步方法实现共享数据的同步(特点：同步块的同步对象为this,如果同步对象是obj，则会出现index=0)
  SellThread myt1 = new SellThread();
  new Thread(myt1).start();//开启第一个窗口开始售票启动第一个线程
  try{
   Thread.sleep(1);//主线程休眠
  }
  catch(Exception e)
  {
   e.printStackTrace();//sleep方法会抛出异常，所以需要捕获
  }
  myt1.bFlag = true;//改变bFlag得值为true
  new Thread(myt1).start();//开启第二个窗口开始售票

}
}
//对某一个Object对象进行加锁
class SellThread implements Runnable
{
int tickets= 100;//100张票
Object obj =  new Object();//同步变量
boolean bFlag = false;//同步方法和同步块转换的条件
public void run()
{
   if(bFlag==false)
   {
    while(true)
     sell();
   }else    {
    while(true)
    {
     //同步块
synchronized(this)
     {
      if(tickets>0)
      {
       try{
         Thread.sleep(10);
        }
        catch(Exception e){
         e.printStackTrace();
        }
       System.out.println("同步块线程："+Thread.currentThread().getName()+"sell==="+tickets);
       tickets--;
      }
     }
    }
   }

}

//同步方法
public synchronized void sell()
{
  if(tickets>0)
  {
   try{
    Thread.sleep(10);
   }
   catch(Exception e){
    e.printStackTrace();
   }
   System.out.println("同步方法线程："+Thread.currentThread().getName()+"sell==="+tickets);
   tickets--;
  }
}
}

>>6线程同步时发生的死锁
线程A和B，A的同步对象m,n,B的同步也是对象m,n，进程A运行时先锁住m，进程B运行时先锁住n，A进程要用到n对象能完成但是n已经被B锁住，所以进程A进入等待状态，B进程要用到m对象才能完成但是m对象已经被A锁住，所以进程B也进入等待状态，出现死锁。
《红色标记为出现死锁得代码，注意与上例的比较》
public class TestThread
{
public static void main(String[] args)
{
  SellThread myt1 = new SellThread();
  new Thread(myt1).start();//开启第一个窗口开始售票
  try{
   Thread.sleep(1);//主线程休眠
  }
  catch(Exception e)
  {
   e.printStackTrace();//sleep方法会抛出异常，所以需要捕获
  }
  myt1.bFlag = true;//改变b得值为true
  new Thread(myt1).start();//开启第二个窗口开始售票
}
}
//对某一个对象进行加锁
class SellThread implements Runnable
{
int tickets= 100;//100张票
Object obj =  new Object();//同步变量
boolean bFlag = false;
public void run()
{

   if(bFlag==false)
   {
    while(true)
     sell();
   }else
   {
    while(true)
    {
    //同步块
synchronized(obj)
      {
           try{
                     Thread.sleep(10);
            }
              catch(Exception e){
                    e.printStackTrace();
             }

                synchronized(this)
                 {
                      if(tickets>0)
                      {
                             System.out.println("同步块线程："+Thread.currentThread().getName()+"sell==="+tickets);
                              tickets--;
                     }
            }
     }
    }
   }

}

//同步方法
public synchronized void sell()
{
  synchronized(obj)
  {
   if(tickets>0)
   {
    try{
     Thread.sleep(10);
    }
    catch(Exception e){
     e.printStackTrace();
    }
    System.out.println("同步方法线程："+Thread.currentThread().getName()+"sell==="+tickets);
    tickets--;
   }
  }

}
}

>>7"生产者--消费者"模型 " 等待--通知(wait---notify)"模型。一定是同步方法且作用同一个对象
public class TestThread
{
public static void main(String[] args)
{
MyQueue q = new MyQueue();
//创建生产者
  Producer p = new Producer(q);
//创建消费者
  Consumer c = new Consumer(q);
//开始成产
  p.start();
//k开始消费
  c.start();
}
}
//树洞类存放和取走数据
//存放和取走得方法都是同步的方法，且针对同一个变量value
class MyQueue
{
//数据变量value
int value =0;
//标记数据是否被取走得变量bFull
boolean bFull = false;
//消费者获得数据得方法
synchronized int  get()
{
  //如果不是满的，也就是没有数据，则等待生产者放入数据
  if(!bFull)
  {
   try
   {
    wait();
   }
   catch (Exception e)
   {
    e.printStackTrace();
   }
  }
  //改变是否取走数据得状态标记的值
  bFull = false;
  //通知生产者，放入数据
  notify();
  //返回数据，消费者取走数据
  return value;
}
//生产者放入数据的方法
synchronized void  set(int intValue)
{
  //如果数据不是满的，也就是数据被消费者取走了，则放入数据
  if(!bFull)
  {
   //生产者放入数据
   this.value = intValue;
   //改变数据是否被取走得标记
   bFull = true;
   //通知消费者来取数据
   notify();
  }
  //如果数据是满的，也就是消费者还没哟取数据，则等待消费折取走数据
  try{
   wait();
  }
  catch(Exception e){
   e.printStackTrace();
  }
}
}
//生产者类---情报员
class Producer extends Thread
{
MyQueue q;
Producer(MyQueue q)
{
  this.q = q;
}
public void run()
{
  for(int i=0;i<10;i++)
  {
   q.set(i);
   System.out.println("set==="+i);
  }
}
}

//消费者类 ---情报员
class Consumer extends Thread
{
MyQueue q;
Consumer(MyQueue q)
{
  this.q = q;
}
public void run()
{
  while(true)
  {
   System.out.println("get====="+q.get());
  }
}
}

>>7终止线程得方法：1变量控制
public class TestThread
{
public static void main(String[] args)
{
  Consumer c = new Consumer();
  c.start();
  int index =0;
  while(true){
   if(index++==500)
   {
   c.stopThread();//改变while循环的变量条件
    break;  //终止线程
   }
   System.out.println("main名字："+Thread.currentThread().getName()+"index===="+index);
  }
  //程序结束输出
  System.out.println("main  exit()");
}
}
class Consumer extends Thread
{
//while循环的条件变量
private boolean bStop = false;
public void run()
{
  while(!bStop)
  {
   System.out.println("子线程名字："+getName());
  }
}
//关闭线程的方法：改变while循环变量得条件
public void stopThread()
{
this.bStop  = true;
}
}

>>8带有wait方法的线程关闭方法2 ：interrupt方法

public class TestThread
{
public static void main(String[] args)
{
  Consumer c = new Consumer();
  c.start();
  int index =0;
  while(true){
   if(index++==500)
   {
   c.stopThread();//改变while循环的变量条件终止线程
    c.interrupt(); //关闭线程
    break;
   }
   System.out.println("main名字："+Thread.currentThread().getName()+"index===="+index);
  }
  //程序结束输出
  System.out.println("main  exit()");
}
}
class Consumer extends Thread
{
//while循环的条件变量
private boolean bStop = false;
//wait方法一定要在静态方法或者静态块中
public synchronized void run()
{
  while(!bStop)
  {
   try{
    wait();//带有wait
   }
   catch(InterruptedException e)
   {
    //异常处理
    if(bStop){
     return ;
    }
   }
   System.out.println("子线程名字："+getName());
  }
}
//关闭线程的方法：改变while循环变量得条件
public void stopThread()
{
  this.bStop  = true;
}
}

>>一个完整的内部类例子
//内部类实现
public class SellTicket
{
private  int tickets=100;
public SellTicket ()
{}
//内部类，继承Thread
class Sellor extends Thread
{
//重写run方法
  public void run()
  {
   synchronized(this)
   {
    while(tickets>0)
    {

     System.out.println(Thread.currentThread().getName()+"sells  tickets====="+tickets);
     tickets--;
    }
   }
  }
//方法返回值为Thread，返回内部类自己的实体对象(因为内部类已经继承了Thread或者实现了Runnable接口)
  public Thread getSellor()
  {
   return new Sellor();
  }

}
public static void main(String[] args)
{
  SellTicket sell = new SellTicket();
//调用内部类的线程并启动run方法
  sell.new Sellor().getSellor().start();
}
}
>>关于重写run方法的理解
一个类继承自Thread，此时可以不重写run方法，就等于使用Thread的run方法，run(){}方法是空的，所以没有意义但是不会出错；
一个类实现了 Runnable接口必须实现run方法，这是实现接口要求的，否则会出错