多线程学习笔记

最新推荐文章于 2024-05-21 10:23:42 发布
最新推荐文章于 2024-05-21 10:23:42 发布
阅读量77 收藏
点赞数
分类专栏： 多线程基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nazi_/article/details/118913702
版权

垃圾回收

public class Demo01Thread {
    /*
     * 进程：电脑中正在运行的程序
     *           正在开工的工厂
     *    
     * 线程：电脑中正在运行的程序中正在执行的代码块
     *           开工的工厂中正在运作的流水线
     * 
     * 线程是进程执行单元
     * 线程是代码块在内存中的执行空间																														
     * 一个进程至少包含一个线程
     * 一个进程中有多个线程在执行---多线程、线程并发
     * 
     * 线程（英语：thread）是操作系统能够进行运算调度的最小单位。
     * 它被包含在进程之中，是进程中的实际运作单位。
     * 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
     * 
     * 感受一下多线程：
     * 一个类要运行必须有main方法：：虚拟机在运行一个类时 会为此类的main方法创建一个线程(main线程) 
     *                       为此线程分配执行空间 来运行main方法中的代码
     * 平常的类运行是由两个线程在并行执行：
     *    main线程--执行main方法中的代码
     *    垃圾回收相关的线程---专门用于垃圾回收相关代码的线程
     * 
     *java来源：从c语言++ --而来
     *添加了面向对象+垃圾回收
     *java垃圾回收机制：虚拟机会不定时的启动垃圾回收器对象，垃圾回收器对象会根据内存中的对象是否存在更多引用
     *             来判断此对象是否为垃圾  如果是垃圾就调用对象的finalize()方法 销毁对象释放内存
     *             程序员可以通过System.gc()来干涉垃圾回收器机制 来主动启动垃圾回收器
     * 
     * 多线程原理： CPU在时间轮片内只执行一个线程的代码 时间轮片到期 在多个线程之间随机切换
     *          时间轮片：时间单位--25ms
     *          
     * java支持多线程：通过Thread类创建线程          
     * 
     * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		System.out.println(111);
//		hehe();
		for (int i = 0; i <20; i++) {
			  new Teacher();
		}
		System.gc();//主动启动垃圾回收器
		for (int i = 0; i < 1000; i++) {
			for (int j = 0; j <10; j++) {
				if(i%100==0&&j==4) {
					System.out.println("main方法   i="+i);
				}
			}
		}
	}
//	public static void hehe() {
//	  Object o=new Object();
//	}
}
class Teacher{
	public final int num;
	private static int n;
	public Teacher() {
		n++;
		num=n;
	}
	@Override
	public String toString() {
		return "Teacher [num=" + num + "]";
	}
	@Override
	protected void finalize() throws Throwable {
		System.out.println(this+"的finalize方法被调用了！");
		super.finalize();
	}
}

Thread 线程

  /*
     * 进程：电脑中正在运行的程序
     *           正在开工的工厂
     *    
     * 线程：电脑中正在运行的程序中正在执行的代码块
     *           开工的工厂中正在运作的流水线
     * 
     * 线程是进程执行单元
     * 线程是代码块在内存中的执行空间															
     * 一个进程至少包含一个线程
     * 一个进程中有多个线程在执行---多线程、线程并发
     * 
     * 线程（英语：thread）是操作系统能够进行运算调度的最小单位。
     * 它被包含在进程之中，是进程中的实际运作单位。
     * 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
     * 
     * 感受一下多线程：
     * 一个类要运行必须有main方法：：虚拟机在运行一个类时 会为此类的main方法创建一个线程(main线程) 
     *                       为此线程分配执行空间 来运行main方法中的代码
     * 平常的类运行是由两个线程在并行执行：
     *    main线程--执行main方法中的代码
     *    垃圾回收相关的线程---专门用于垃圾回收相关代码的线程
     * 
     *java来源：从c语言++ --而来
     *添加了面向对象+垃圾回收
     *java垃圾回收机制：虚拟机会不定时的启动垃圾回收器对象，垃圾回收器对象会根据内存中的对象是否存在更多引用
     *             来判断此对象是否为垃圾  如果是垃圾就调用对象的finalize()方法 销毁对象释放内存
     *             程序员可以通过System.gc()来干涉垃圾回收器机制 来主动启动垃圾回收器
     * 
     * 多线程原理： CPU在时间时间轮片内只执行一个线程的代码 时间轮片到期 在多个线程之间随机切换
     *          时间轮片：时间单位--25ms
     *          
     * java支持多线程：通过Thread类创建线程          
     * 
     * */

创建线程

/*
     * Thread:
     * 构造方法：
     *    Thread() 
     *        不指定线程名字,自动生成的名称的形式为 "Thread-"+n，其中的 n 为整数。 
     *    Thread(String name) 
     *        参数是线程名字
     *    Thread(Runnable target) 
     *    Thread(Runnable target, String name) 
                     普通方法：
          void setName(String name) :设置线程名字
          String getName()  :获取线程名字
          void start()  : 驱动线程   jvm才会为此线程分配执行空间  然后调用当前线程的run方法 执行线程任务
          void run()    : 线程任务封装
          static void sleep(long millis) ：线程休眠指定毫秒
          static Thread currentThread() ：获取当前线程
     * 创建线程的方式一：
     * 一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例
     * 1: 创建类继承Thread类
     * 2: 重写run方法
     *    (重写的要求：除了范围修饰符可以扩大 抛出的异常可以少、小 其他方法声明必须和父类完全相同)
     * 3: 创建自定义线程对象  
     * 
     * 总结：继承Thread 重写run
     * 
     * 
     * */

代码：

public static void main(String[] args) {
      //3  ：创建自定义线程对象
	  MyThread2_1 m1=new MyThread2_1();
	  m1.setName("自定义线程1111");//给线程起个名字
	  //4:启动线程
	  m1.start();//此时有两个线程：：：main线程和m1线程
	  
	  new MyThread2_1("自定义线程22222222").start();
	 //此时有三个线程：：：main线程和m1线程和m2线程
	  
	  for (int i = 0; i < 10; i++) {
		   char c=(char)(Math.random()*26+'a');
		   Thread t=Thread.currentThread();//获取当前线程
		   System.out.println(t.getName()+"线程    打印字母的线程：：：c="+c);
		    //线程休眠：
		   try {Thread.sleep(100); } catch (Exception e) {throw new RuntimeException(e); } 
	  }
	  
}
}
//1: 创建类继承Thread类
class MyThread2_1 extends Thread{
	public MyThread2_1() {}
	public MyThread2_1(String name) {
		super(name);
	}
	//2: 重写run方法:当前线程要执行的代码块
	public void run() {
		  for (int i = 0; i < 10; i++) {
			   char c=(char)(Math.random()*10+'0');
			   System.out.println(Thread.currentThread().getName()+"    打印数字的线程：：：c="+c);
			   //线程休眠：
			   try {Thread.sleep(100); } catch (Exception e) {throw new RuntimeException(e); } 
		  }
	}
}

* 创建线程的方式二：
 * 声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动
 * 1: 创建Runnable的实现类
 * 2: 实现run方法：封装线程任务
 * 3: 创建实现类对象
 * 4:创建线程对象 并通过构造方法参数关联实现类对象
 * 5:启动线程
 * 
 * 总结：实现Runnable接口 实现run方法

代码：

public static void main(String[] args) {
	 //3: 创建实现类对象
	MyRunnable mr=new MyRunnable();
	//4:创建线程对象 并通过构造方法参数关联实现类对象
	Thread t1=new Thread(mr);
	t1.setName("线程111");
	//5:启动线程
	t1.start();
	Thread t2=new Thread(mr,"线程222222");
	//5:启动线程
	t2.start();
	
	for (int i = 0; i < 10; i++) {
		   char c=(char)(Math.random()*26+'a');
		   Thread t=Thread.currentThread();//获取当前线程
		   System.out.println(t.getName()+"线程    打印字母的线程：：：c="+c);
		    //线程休眠：
		   try {Thread.sleep(100); } catch (Exception e) {throw new RuntimeException(e); } 
    }
}
}
//1: 创建Runnable的实现类
class MyRunnable implements Runnable{
	//2: 实现run方法：封装线程任务
	public void run() {
		  for (int i = 0; i < 10; i++) {
			   char c=(char)(Math.random()*10+'0');
			   System.out.println(Thread.currentThread().getName()+"    打印数字的线程：：：c="+c);
			   //线程休眠：
			   try {Thread.sleep(100); } catch (Exception e) {throw new RuntimeException(e); } 
		  }
	}
}

继承Thread 类重写run方法创建三个线程

public class Demo04 {
    //创建三个线程分别打印大写 小写  数字
	public static void main(String[] args) {
		//3 创建线程对象
		//4 开启线程
		new ThreadPrint("大写线程---", 'A', 26).start();
		new ThreadPrint("小写线程++++++++", 'a', 26).start();
		new ThreadPrint("数字线程！！！！！！！！！", '0', 10).start();
	}
}
//一个方法中可以使用的变量：成员变量，方法体中的局部变量，参数列表
//1 继承Thread类
class ThreadPrint extends Thread{
	ThreadPrint(String name,char startChar, int fw){
		super(name);
		this.startChar=startChar;this.fw=fw;
	}
	private char startChar;private int fw;//定义成员变量记录范围和起始值
	//2 重写run方法
	public void run() {
		for (int i = 0; i <20; i++) {
			char c=(char)(Math.random()*fw+startChar);
			System.out.println(this.getName()+":::"+i+"   "+c);
			try {Thread.sleep(100);} catch (Exception e) {throw new RuntimeException(e);}
		}
	}	
}

实现Runnable接口实现run方法创建三个线程：

//创建三个线程分别打印大写 小写  数字
	public static void main(String[] args) {
	     //3 创建实现类对象：三个线程的线程任务不同 需要创建三个实现类对象
		MyRunnablePrint  pdx=new MyRunnablePrint('A', 26);
		MyRunnablePrint  pxx=new MyRunnablePrint('a', 26);
		MyRunnablePrint  psz=new MyRunnablePrint('0', 10);
		//4 创建线程对象 与实现类对象关联
		Thread tA=new Thread(pdx, "大写线程---");
		Thread ta=new Thread(pxx, "小写线程------");
		Thread t1=new Thread(psz, "数字线程----------");
		//5启动线程
		ta.start();tA.start();t1.start();
	}	
}
//1 创建Runnable的实现类
class MyRunnablePrint implements Runnable{
	private char startChar;private int fw;//定义变量传递随机范围和起始值
	MyRunnablePrint(char startChar, int fw){
		this.startChar=startChar;this.fw=fw;
	}
	//2 实现run方法
	public void run() {
		for (int i = 0; i <20; i++) {
			char c=(char)(Math.random()*fw+startChar);
			System.out.println(Thread.currentThread().getName()+":::"+i+"   "+c);
			try {Thread.sleep(100);} catch (Exception e) {throw new RuntimeException(e);}
		}
	}
}

创建线程两种方式的优缺点

/*创建线程的两种方式：
	 *  1 继承Thread类 重写run方法
	 *  2 实现Runnable接口 实现run方法
	 *比较优缺点：
	 *
	 *  继承Thread类优点步骤简单 容易；理解
	 *  实现Runnable接口优点：
	 *       1  Runnable的实现类是对线程任务的封装 更符合java完全面向对象的思想
	 *       2  java只支持类与类的单继承    继承Thread后 无法再扩展
	 *          java支持类实现多个接口 并且不影响继承其他类  实现Runnable后 不影响类的扩展
	 *总结：工作过程中建议使用方式2        
	 * 
	 * 完全面向对象：每个独立的功能 尽量都封装为独立的部件/对象
	 * 
	 * /

模拟通过实现Runnable接口创建的Thread对象调用Runnable接口实现类的run方法的过程

public static void main(String[] args) {
    
}
//模拟Runnable
interface MyRunnable1{
	void run();
}
//模拟Thread
class MyThread{
	private MyRunnable1 r;
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	MyThread(){name="Thread_"+0;}
	MyThread(MyRunnable1 r){
		this.r=r;
		name="Thread_"+0;
	}
	MyThread(String name){this.name=name;}
	MyThread(MyRunnable1 r,String name){
		this.r=r;
		this.name=name;
	}
	public void run() {
		System.out.println("线程任务：：：Thread自带的run方法");
	}
	public void start() {
		//线程开启 虚拟机自动调用当前线程的run方法
		if(r!=null) {
			r.run();
		}else {
			this.run();
		}
	}
}

join()

/*public final void join()
    * 在a线程任务中调用b线程的join方法  a线程会等待 直到b线程执行完毕 b线程才继续执行
    * 两个线程：一个对应30个数字 一个打印30个小写字母 要求打印数字的打印到5时 必须等待对应小写的执行完才能继续执行
    * 
    */

	public static void main(String[] args) {
		ThreadPrintSZ  tsz=new ThreadPrintSZ();
		tsz.setName("打印数字---");
		ThreadPrintXX  tXX=new ThreadPrintXX();
		tXX.setName("打印小写-------");
		tXX.start();
		tsz.t=tXX;//给ThreadPrintSZ的t属性赋值 
		tsz.start();
		//tsz.start();
	
	}

}
class ThreadPrintSZ extends Thread{
	ThreadPrintXX  t;
	public void run() {
		for (int i = 0; i <30; i++) {
			char c=(char)(Math.random()*10+'0');
			System.out.println(Thread.currentThread().getName()+":::"+i+"::::"+c);
			try {Thread.sleep(100);} catch (Exception e) {throw new RuntimeException(e);}
			//判断随机的字符是不是5 如果是5 就调用tXX的join方法
			if(c=='5') {
				try {t.join();} catch (Exception e) {throw new RuntimeException(e);}
			}
		}
	}
}
class ThreadPrintXX extends Thread{
	public void run() {
		for (int i = 0; i <30; i++) {
			System.out.println(Thread.currentThread().getName()+":::"+i+"::::"+(char)(Math.random()*26+'a'));
			try {Thread.sleep(100);} catch (Exception e) {throw new RuntimeException(e);}
		}
	}
}

线程死锁

1.join实现线程死锁

public class Demo01DieLock {
    /*
     * 线程死锁：多线程无法继续执行
     * 死锁情况1： 两个线程互相调用对方的join方法
     * 
     * */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TestDie t1=new TestDie();t1.setName("线程111");
		TestDie t2=new TestDie();t2.setName("线程2222222");
		t1.t=t2;t2.t=t1;
		t1.start();t2.start();
	}
}
class TestDie extends Thread{
	Thread t;//定义引用记录要等待的线程对象
	public void run() {
		while(true) {
			System.out.println(getName()+"::::"+System.currentTimeMillis());
			//try {Thread.sleep(10);} catch (Exception e) {throw new RuntimeException(e);}
			try {t.join();} catch (Exception e) {throw new RuntimeException(e);}
		}
	}
}

2.synchronized [ˈsɪŋkrənaɪzd] 实现线程死锁

public class Demo04DieLock {
   /*线程死锁：通过synchronized实现线程死锁
    * 两个线程：每个线程ab都有两个互相嵌套的同步代码块
    *        a线程的外锁 作为b线程的内锁  让a线程的内锁作为b线程外锁
    * 
    * */
	public static void main(String[] args) {
		Object a=new Object();Object b=new Object();
		ThreadDie t1=new ThreadDie();
		t1.wai=a;t1.nei=b;
		ThreadDie t2=new ThreadDie();
		t2.wai=b;t2.nei=a;
		t1.start();t2.start();
	}

}
class ThreadDie extends Thread{
	Object nei;Object wai;
	public void run() {
		while(true) {
			System.out.println(getName()+"无锁状态！");
			synchronized (wai) {
				System.out.println(getName()+"拿到其外锁++："+wai);
				synchronized (nei) {
					 System.out.println(getName()+"拿到其内锁++++："+nei);
				}
				System.out.println(getName()+"放开了其内锁---------："+nei);
			}
			System.out.println(getName()+"放开了其外锁---------------："+wai);
		}
	}
}

synchronized 同步锁

public class Demo02 {
    /*线程安全问题： 多个线程的多个语句操作共享数据时  出现前后数据不一致的现象
     *解决线程安全问题：当某个线程在使用共享数据过程中   如果其他线程也要使用共享数据  就等待 
     *通过同步代码块来解决线程安全问题：
     *   synchronized(对象){
     *      操作共享数据的语句
     *   }
     *注意1： 同步代码块必须包含了所有操作共享数据的代码
     *注意2：synchronized的对象--锁对象---类型可以是任意类型
     *注意3：多个线程的锁对象必须是同一个锁对象
     *
     *
     */
	

	public static void main(String[] args) {
		WindowThread2  w11=new WindowThread2();w11.setName("窗口1");
		WindowThread2  w12=new WindowThread2();w12.setName("窗口12222");
		WindowThread2  w13=new WindowThread2();w13.setName("窗口133333333");
		Train2  tt=new Train2();
		w11.t=tt;
		w12.t=tt;  
		w13.t=tt;
		w11.start();
		w12.start();w13.start();		
	}  
}
//定义类 描述火车
class Train2{
	public int num=1; 
}
//定义类 描述窗口：多个窗口卖票 之间互不影响  需要定义为线程类
class WindowThread2 extends Thread{
	public Train2 t;
	//static Object obj=new Object();//定义一个对象记录锁对象
	public void run() {
		//Object obj=new Object();
		while(true) {
			//Object obj=new Object();
			synchronized (t) {
				if(t.num<=100) {
					System.out.println(Thread.currentThread().getName()+" 卖了一张票  票号是："+t.num);
					try {Thread.sleep(50);} catch (Exception e) {throw new RuntimeException(e);}
					t.num++;
				}else {
					break;
				}
			}
			try {Thread.sleep(50);} catch (Exception e) {throw new RuntimeException(e);		
		}
	}
}

synchronized同步方法

public class Demo03 {
	/*

  * 同步方法：当一个方法的方法体要求同步时  可以把此方法定义为同步方法---加修饰符synchronized
    * 同步方法的锁对象是this
     * 静态同步方法的锁对象是当前类的Class文件:::类名.class
     * */
       //2 新生入校：一个线程登记：学生姓名+性别(给对象的属性赋值)    一个线程打印：姓名和性别
       public static void main(String[] args) {
       Person p=new Person();
       ThreadWrite tw=new ThreadWrite();
       ThreadPrint tp=new ThreadPrint();
       tw.p=p;tp.p=p;
       tw.setName("负责登记的线程");
       tp.setName("负责打印的线程");
		tw.start(); tp.start();
	}
}
class Person{
	char sex;
	String name;
	public synchronized void set(boolean b) {//同步方法:同步方法的锁是this
		if(b) {
			this.sex='男';this.name="tom";
		}else {
			this.sex='女';this.name="韩梅梅";
		}
	}
	public static synchronized void hehe() {	

	}

}
//两个线程类 公用一个person
class ThreadWrite extends Thread{
	Person p;
	public void run() {
		boolean b=true;
		while(true) {
//			synchronized (p) {
				if(b) {
					p.sex='男';p.name="tom";
				}else {
					p.sex='女';p.name="韩梅梅";
				}
//				//p.set(b);//set方法的所有代码需要完全设置到同步代码块中  这样的方法可以设置为同步方法
//			}
			
			

			//p.set(b);
			
			if(Math.random()>0.5) {
				synchronized (p) {
					if(b) {
						p.sex='男';p.name="tom";
					}else {
						p.sex='女';p.name="韩梅梅";
					}
				}
			}else {
				p.set(b);
			}
			
			b=!b;
			try {Thread.sleep(50);} catch (Exception e) {throw new RuntimeException(e);}
		}
	}

}
class ThreadPrint extends Thread{
	Person p;
    public void run() {
		while(true) {
			synchronized (p) {
				System.out.print(this.getName()+"::::"+p.name);
				try {Thread.sleep(50);} catch (Exception e) {throw new RuntimeException(e);}
				System.out.println("::::"+p.sex);
			}
			

			try {Thread.sleep(50);} catch (Exception e) {throw new RuntimeException(e);}
		}
	}

}

void wait()

让当前线程等待：失去拿锁的资格  失去cpu随机的资格

void notify()

随机唤醒一个正在等待的线程

代码实例：

public class Demo05ShaoBing {
    /*
     * 怎么实现做一个 吃一个
     * Object类中的方法：
     * void wait()  :  当前线程等待：失去拿锁的资格  失去cpu随机的资格
     * void notify():  随机唤醒一个正在等待的线程
     * 
     * 
     * */
	public static void main(String[] args) {
		ShaoBing  shb=new ShaoBing();
		SaleThread st=new SaleThread();st.setName("武大郎1");
		SaleThread st2=new SaleThread();st2.setName("武大郎222");
		EatThread et=new EatThread();et.setName("吃货33333号");
		EatThread et2=new EatThread();et2.setName("吃货444444444号");
		st.shb=shb;st2.shb=shb;  et.shb=shb; et2.shb=shb;
		st.start(); st2.start();  et.start(); et2.start();
	}
}
class ShaoBing{
	int number;
	boolean b=false;//定义变量记录是否有烧饼
}
//一个线程做烧饼
class SaleThread extends Thread{
	ShaoBing shb;
	public void run() {
		while(true) {
			synchronized (shb) {
				if(!shb.b) {
					System.out.println(getName()+"开始做烧饼++++"+(shb.number+1));
					try {Thread.sleep(50);} catch (Exception e) {}
					shb.number++;
					System.out.println(getName()+"做完了烧饼++++"+shb.number);
					shb.b=true;//有烧饼
					shb.notifyAll();//唤醒吃烧饼的线程
				}else {
					try {shb.wait();} catch (Exception e) {}//当前线程等待
				}
			}
			try {Thread.sleep(5);} catch (Exception e) {}
		}
	}
}
//一个线程吃烧饼
class EatThread extends Thread{
	ShaoBing shb;
    public void run() {
    	while(true) {
    		synchronized (shb) {
    			if(shb.b) {
    				System.out.println(getName()+"开始吃烧饼--------"+shb.number);
            		try {Thread.sleep(10);} catch (Exception e) {}
            		System.out.println(getName()+"吃完了烧饼--------"+shb.number);
            		shb.b=false;
            		shb.notifyAll();//唤醒做烧饼的线程
    			}else {
					try {shb.wait();} catch (Exception e) {}//当前线程等待
				}
			}
    		try {Thread.sleep(20);} catch (Exception e) {}
    	}
	}
}
Nazi_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#多线程学习笔记
wangyunman的博客
08-23 718
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3177
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
多线程学习笔记05线程协作
asdfghjkl_zth的博客
02-01 2529
文章目录多线程学习笔记05线程协作线程通信解决方式1管程法解决方式2信号灯法 多线程学习笔记05线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费； 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止； 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 我们来分析一下： 首先，这是一个线程同步问题，生产者和消费者共享同一个资
Java多线程学习笔记
Mike_ToUp
06-15 650
进程和线程的概念 进程：程序（任务）的执行过程。持有资源（共享内存，共享文件）和线程 线程：系统中最小的执行单元。同一进程中有多个线程。 线程共享进程的资源。 线程的交互：互斥/同步Java语言对线程的支持示意图： Thread常用方法：线程的创建：Thread（String name） / Thread（Runnable target）线程的方法： 启动线程：void start（） 线程休眠
java多线程学习笔记
weach的博客
12-19 568
java多线程
C++多线程学习笔记（一）
m0_63932570的博客
05-04 2037
今天是五月三号，五一放假五天，博主也就给自己放了三天假，去游山玩水，吃美食。今天是第四天了，也该慢慢找回学习的状态啦。所以今天博主也是改变自己最近懒惰的状态，来开始自己学习多线程的基础知识。多线程这部分内容对于java，c++爱好者应该不陌生，经常听到或看到的吧。建议在学完c++基础语言知识后的同学们，还是值得学一下这部分内容的（其实也不算很多内容）。下面我们正式开始来看看吧 1.理解多线程。 多线程并发指的是在同一个进程中执行多个线程。C++11提供了语言层面上的多线程，包含在头文件<threa
Java多线程学习笔记(七)--线程池
热门推荐
至尊宝
05-19 2万+
什么是线程池 为了避免系统频繁地创建和销毁线程,我们可以让创建的线程进行复用,线程池是来管理线程的,线程池中总有那么几个活跃线程,当使用线程时可以从池子中随便拿一个空闲线程,当完成工作时,不用立即关闭线程,而是将线程还给线程池,方便下一个要使用线程的任务,有了线程池后,创建线程变成是从线程池中拿线程,销毁线程时变成是将线程还给线程池继续管理。 这种场景非常像在开发中连接数据库,有一个数据库连...
Java多线程学习笔记 - 1
涞公子的博客
03-13 2405
多任务 概述： 多任务就是同时运行多个任务。 好处： 充分利用了CPU的资源，提高了代码的执行效率。 执行方式： 并发：在一段时间内交替去执行多项任务【任务数 > 核数】 并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】 实现方式： 多线程或多进程。 进程与线程介绍： 进程 概述： 线程 概述： 进程与线程之间的关系 一个进程内含有一个或多个线程，但至少含有一个线程。 ...
狂神说多线程学习笔记
qq_40492693的博客
04-13 577
很多多线程都是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一行代码，因为切换的很快，所以就有同时执行的错局。
JAVA 多线程学习笔记
03-27
NULL 博文链接：https://baobeituping.iteye.com/blog/1190260
多线程学习笔记.docx
06-16
包括线程和进程的关系，线程的三种创建方式，继承thread，实现runnable接口，实现callable接口，线程同步，生产者消费者模式
多线程 学习笔记.md
05-04
多线程 学习笔记.md
jar包增量更新分析
junlaiyan的专栏
05-16 281
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 910
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 640
本文主要提供用java实现的拼图小游戏源代码。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 41
1，引入核心关键依赖。
Java多线程编程学习笔记之十二：生产者—消费者模型（含代码）
06-02
好的，下面是Java多线程编程学习笔记之十二：生产者—消费者模型的相关内容和代码。 ## 生产者—消费者模型简介 生产者—消费者模型是一种常见的多线程并发模型，它涉及到两个角色：生产者和消费者。生产者负责生产数据，消费者负责消费数据。生产者和消费者通过一个共享的缓冲区进行通信，生产者将数据放入缓冲区，消费者从缓冲区获取数据。 在多线程编程中，生产者—消费者模型的实现有多种方式，本文将介绍一种基于Java的实现方式。 ## 生产者—消费者模型的实现 ### 1. 定义共享缓冲区 共享缓冲区是生产者和消费者进行通信的桥梁，它需要实现以下功能： - 提供一个put方法，允许生产者将数据放入缓冲区； - 提供一个take方法，允许消费者从缓冲区获取数据； - 当缓冲区已满时，put方法应该等待； - 当缓冲区为空时，take方法应该等待。 以下是一个简单的共享缓冲区的实现： ```java public class Buffer { private int[] data; private int size; private int count; private int putIndex; private int takeIndex; public Buffer(int size) { this.data = new int[size]; this.size = size; this.count = 0; this.putIndex = 0; this.takeIndex = 0; } public synchronized void put(int value) throws InterruptedException { while (count == size) { wait(); } data[putIndex] = value; putIndex = (putIndex + 1) % size; count++; notifyAll(); } public synchronized int take() throws InterruptedException { while (count == 0) { wait(); } int value = data[takeIndex]; takeIndex = (takeIndex + 1) % size; count--; notifyAll(); return value; } } ``` 上面的Buffer类使用一个数组来表示缓冲区，size表示缓冲区的大小，count表示当前缓冲区中的元素数量，putIndex和takeIndex分别表示下一个可写和可读的位置。put和take方法都是同步方法，使用wait和notifyAll来进行线程间的等待和通知。 ### 2. 定义生产者和消费者 生产者和消费者都需要访问共享缓冲区，因此它们都需要接收一个Buffer对象作为参数。以下是生产者和消费者的简单实现： ```java public class Producer implements Runnable { private Buffer buffer; public Producer(Buffer buffer) { this.buffer = buffer; } public void run() { try { for (int i = 0; i < 10; i++) { buffer.put(i); System.out.println("Produced: " + i); Thread.sleep((int)(Math.random() * 1000)); } } catch (InterruptedException e) { e.printStackTrace(); } } } public class Consumer implements Runnable { private Buffer buffer; public Consumer(Buffer buffer) { this.buffer = buffer; } public void run() { try { for (int i = 0; i < 10; i++) { int value = buffer.take(); System.out.println("Consumed: " + value); Thread.sleep((int)(Math.random() * 1000)); } } catch (InterruptedException e) { e.printStackTrace(); } } } ``` 生产者在一个循环中不断地向缓冲区中放入数据，消费者也在一个循环中不断地从缓冲区中获取数据。注意，当缓冲区已满时，生产者会进入等待状态；当缓冲区为空时，消费者会进入等待状态。 ### 3. 测试 最后，我们可以使用下面的代码来进行测试： ```java public class Main { public static void main(String[] args) { Buffer buffer = new Buffer(5); Producer producer = new Producer(buffer); Consumer consumer = new Consumer(buffer); Thread producerThread = new Thread(producer); Thread consumerThread = new Thread(consumer); producerThread.start(); consumerThread.start(); } } ``` 在上面的代码中，我们创建了一个缓冲区对象和一个生产者对象和一个消费者对象，然后将它们分别传递给两个线程，并启动这两个线程。 运行上面的代码，我们可以看到生产者和消费者交替地进行操作，生产者不断地向缓冲区中放入数据，消费者不断地从缓冲区中获取数据。如果缓冲区已满或者为空，生产者和消费者会进入等待状态，直到缓冲区中有足够的空间或者有新的数据可用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值