多线程

最新推荐文章于 2024-03-17 21:20:55 发布

wudongqiji1203

最新推荐文章于 2024-03-17 21:20:55 发布

阅读量251

点赞数

分类专栏： java android

本文链接：https://blog.csdn.net/wudongqiji1203/article/details/47998451

版权

java 同时被 2 个专栏收录

16 篇文章 0 订阅

订阅专栏

android

14 篇文章 0 订阅

订阅专栏

一、多线程的理解

1、进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

2、线程：实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

3、多线程：在java虚拟机启动的时候会有一个java.exe的执行程序，也就是一个进程。该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。JVM启动除了执行一个主线程，还有负责垃圾回收机制的线程。像种在一个进程中有多个线程执行的方式，就叫做多线程。

4、进程与线程的区别：

（1）、功能上：线程是处理器的调度对象，而进程是资源分配的对象。
（2）、内存上：每个进程都有独立的代码和数据空间并且进程间的切换开销大，同一个进程内的多个线程共享相同的代码和数据空间可以实现线程间的通信和同步操作，每个线程有毒瘤的运行栈和程序计数器，线程的切换开销小。
（3）、扩展：JAVA虚拟机JVM不只一个线程，还有垃圾回收机制的线程，不过这是守护线程。

5、线程的状态：

被创建：start()
运行：具备执行资格，同时具备执行权；
冻结：sleep(time),wait()—notify()唤醒；线程释放了执行权，同时释放执行资格；
临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
消亡：stop()

二、线程的创建

1、继承Thread ，由子类复写run方法。

步骤：

（1）、定义类继承Thread类

（2）、重写父类中Run方法

（3)、通过创建子类对象,创建线程对象

（4）、调用线程的Star方法,开启线程,接着调用重写后的Run方法

代码演示：

class Demo extends Thread//定义类继承Thread类  
{  
    public void run()//重写Run方法  
    {  
        for(int x=0; x<60; x++)  
            System.out.println("demo run----"+x);  
    }  
}  
class ThreadDemo   
{  
    public static void main(String[] args)   
    {  
        //for(int x=0; x<4000; x++)  
        //System.out.println("Hello World!");  
        Demo d = new Demo();//创建自定义的线程对象。  
        d.start();//对象调用Star方法,开启线程。  
        //d.run();//线程开启后会调用run方法开始执行重写后的run方法  
        for(int x=0; x<60; x++)  
            System.out.println("Hello World!--"+x);  
    }  
}

2、创建线程的第二种方式：实现一个接口Runnable。

步骤：

（1）、定义类实现Runnable接口。

（2）、覆盖接口中的run方法（用于封装线程要运行的代码）。

（3）、通过Thread类创建线程对象；

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

（5）、调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

代码演示：

class Ticket implements Runnable//创建自定义子类实现Runable接口  
{  
    private  int tick = 100;  
    public void run()  //实现Runable方法的run()方法
    {  
        while(true)  
        {  
            if(tick>0)  
            {  
                System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);  //输出当前执行的线程
            }  
        }  
    }  
}  
class  TicketDemo  
{  
    public static void main(String[] args)   
    {  
        Ticket t = new Ticket();  //创建自定义子类的对象
        Thread t1 = new Thread(t);//通过new一个thread类传入子类对象来创立线程对象
        Thread t2 = new Thread(t);
        Thread t3 = new Thread(t); 
        Thread t4 = new Thread(t); 
        t1.start();//调用thread类的Star方法开启线程并调用重写的Run方法
        t2.start();  
        t3.start();  
        t4.start();  
        /* 
        Ticket t1 = new Ticket(); 
        //Ticket t2 = new Ticket(); 
        //Ticket t3 = new Ticket(); 
        //Ticket t4 = new Ticket(); 
        t1.start(); 
        t2.start(); 
        t3.start(); 
        t4.start(); 
        */  
    }  
}  /

三、线程的安全问题

1、出现的原因：

（1）、多个线程访问出现延迟。

（2）、线程随机性。

2、解决方法线程安全的办法是同步。同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

3、同步的前提：

（1）、同步需要两个或者两个以上的线程。
（2）、多个线程使用的是同一个锁。

4、同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

5、多线程版单例模式（同步懒汉式）

class Single  //懒汉模式
{  
  private static  Single s=null;  
  private Single(){}  
  public static  Single getInstance()  
  {  
      if(s==null)  //首先判断对象是否为空
      {  
         synchronized(Single.class)  //同步
          {  
             if(s==null)  
//        --->A  
//        --->B  
             s=new Single();  
           }  
      }  
      return s;  
  }  
}

6、生产者与消费者案例代码演示

public class ProducerConsumerDemo {  
    /**多生产者消费者的情况 
     * 当出现多个线程时，要用while标识和notifyAll 
     * @param args 
     */  
    public static void main(String[] args) {  
        Resource r=new Resource();  
        Produce pro=new Produce(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();  
    }  
}  
class Resource  
{  
 private String name;  
 private int count=1;  
 private boolean flag=false;  
 public synchronized void set(String name)  
 {   while(flag)//用了while出现了全部等待  
    try {  
        wait();  
    } catch (InterruptedException e) {  
        // TODO Auto-generated catch block  
        e.printStackTrace();  
    }  
     this.name=name+"------"+count++;  
     System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);  
  flag=true;  
  this.notifyAll();  
 }  
 public synchronized void out()  
 {  while(!flag)  
     try {  
            wait();  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
     System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);  
   flag=false;  
   this.notifyAll();  
 }  
}  
class Produce implements Runnable  
{  
 private Resource res;  
 Produce(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();  
         }  
}  
}

7、死锁产生的原因：同步中嵌套同步时，就有可能出现死锁现象。

代码演示：

//定义一个类来实现Runnable，并复写run方法
class LockTest implements Runnable
{
	private boolean flag;
	LockTest(boolean flag)
	{
		this.flag=flag;
	}
	public void run()
	{
		if(flag)
		{
			while(true)
			{
				synchronized(LockClass.locka)//a锁
				{
					System.out.println(Thread.currentThread().getName()+"------if_locka");

					synchronized(LockClass.lockb)//b锁
					{
					System.out.println(Thread.currentThread().getName()+"------if_lockb");
					}
				}
			}
		}
		else
		{
			while(true)
			{
				synchronized(LockClass.lockb)//b锁
				{
				  System.out.println(Thread.currentThread().getName()+"------else_lockb");

					synchronized(LockClass.locka)//a锁
					{
				   System.out.println(Thread.currentThread().getName()+"------else_locka");
					}
				}
			}
		}
	}
}

//定义两个锁
class LockClass
{
	static Object locka = new Object();
	static Object lockb = new Object();
}

class DeadLock
{
	public static void main(String[] args)
	{
		//创建2个进程，并启动
		new Thread(new LockTest(true)).start();
		new Thread(new LockTest(false)).start();
	}
}

8、JDK1.5中多线程的升级

（1）、将同步synchronized替换成显示的Lock操作。

（2）、将Object中wait，notify，notifyAll，替换成了Condition对象。

（3）、该Condition对象可以通过Lock锁进行获取，并支持多个相关的Condition对象。

生产者与消费者升级解决放方案代码演示：

import java.util.concurrent.locks.*;  
  
class Resource   
{     
    private String name;  
    private int count=1;  
    private boolean flag = false;  
      
    //多态  
    private Lock lock=new ReentrantLock();  
  
    //创建两Condition对象，分别来控制等待或唤醒本方和对方线程  
    Condition condition_pro=lock.newCondition();  
    Condition condition_con=lock.newCondition();  
  
    //p1、p2共享此方法  
    public void setProducer(String name)throws InterruptedException  
    {  
        lock.lock();//锁  
        try  
        {  
            while(flag)//重复判断标识，确认是否生产  
                condition_pro.await();//本方等待  
  
            this.name=name+"......"+count++;//生产  
            System.out.println(Thread.currentThread().getName()+"...生产..."+this.name);//打印生产  
            flag=true;//控制生产\消费标识  
            condition_con.signal();//唤醒对方  
        }  
        finally  
        {  
            lock.unlock();//解锁，这个动作一定执行  
        }  
          
    }  
  
    //c1、c2共享此方法  
    public void getConsumer()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;  
    }  
    //复写run方法  
    public void run()  
    {  
        while(true)  
        {  
            try  
            {  
                res.setProducer("商品");  
            }  
            catch (InterruptedException e)  
            {  
            }  
        }  
    }  
}  
  
//消费者线程  
class Consumer implements Runnable  
{  
    private Resource res;  
    Consumer(Resource res)  
    {  
        this.res=res;  
    }  
    //复写run  
    public void run()  
    {  
        while(true)  
        {  
            try  
            {  
                res.getConsumer();  
            }  
            catch (InterruptedException e)  
            {  
            }  
        }  
    }  
  
}  
  
class  ProducerConsumer  
{  
    public static void main(String[] args)   
    {  
        Resource res=new Resource();  
  
        new Thread(new Producer(res)).start();//第一个生产线程 p1  
        new Thread(new Consumer(res)).start();//第一个消费线程 c1  
  
        new Thread(new Producer(res)).start();//第二个生产线程 p2  
        new Thread(new Consumer(res)).start();//第二个消费线程 c2  
    }  
}

四、小结

多线程是java基础中比较难的部分，而且在日常的开发过程中也非常常用。故必须牢固掌握多线程的创建，特别是第二种创建方式。在运用多线程的过程中还要注意不要产生死锁。

wudongqiji1203

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程

----------android培训、java培训、java学习型技术博客、期待与您交流！------------一、多线程的理解1、进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。2、线程：实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。3、多线程：在java虚拟机启动的时候会有
复制链接

扫一扫