[ Java学习 ] 线程 书上代码

最新推荐文章于 2022-03-28 21:24:28 发布
最新推荐文章于 2022-03-28 21:24:28 发布
阅读量288 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mofushaohua_ln/article/details/78699878
版权

//这次吸取了之前做实验的教训，在做实验之前，先把书上的有关代码都敲了一次...虽然好像没什么用，因为实验还是做得很艰难...不过这次实验本来就难，所以也许其实是有用的，只是我没感受到罢了...




//TaskThreadDemo.java
public class TaskThreadDemo 
{
	public static void main(String[] args)
	{
		//Create tasks
		Runnable printA = new PrintChar('a', 100);
		Runnable printB = new PrintChar('b', 100);
		Runnable print100 = new PrintNum(100);
		
		//Create threads
		Thread thread1 = new Thread(printA);
		Thread thread2 = new Thread(printB);
		Thread thread3 = new Thread(print100);
		
		//Run threads
		thread1.start();
		thread2.start();
		thread3.start();
	}

}
class PrintChar implements Runnable
{
	//The task for printing a character a specified number of times
	private char charToPrint; //The character to print
	private int times;// The number of times to repeat
	
	//Construct a task with specified character and number of times to print the character
	public PrintChar(char c, int t)
	{
		charToPrint = c;
		times = t;
	}
	
	//Override the run() method to tell the system what task to perform
	public void run()
	{
		for (int i = 0; i < times; i++)
			System.out.print(charToPrint);
		System.out.println();
	}
}

//The task for printing numbers from 1 to n for a giving n
class PrintNum implements Runnable
{
	private int lastNum;
	
	//Construct a task for printing 1, 2, 3, ..., n
	public PrintNum(int n)
	{
		lastNum = n;
	}
	
	//Tell the thread how to run
	public void run()
	{
		for (int i = 1; i <= lastNum; i++)
			System.out.print(" " + i);
		System.out.println();
	}
}

/*重要注意事项：
 * 任务中的 run() 方法指明如何完成这个任务。Java虚拟机会自动调用该方法，无需特意调用它。
 * 直接调用 run() 只是在同一个线程中执行该方法，而没有新线程被启动
 */

import javax.swing.*;
public class FlashingText extends JApplet implements Runnable
{
	private JLabel j1b1Text = new JLabel("Welcome", JLabel.CENTER);
	
	public FlashingText()
	{
		add(j1b1Text);
		new Thread(this).start();
	}
	
	// Set the text on/off every 200 milliseconds
	public void run()
	{
		try
		{
			while (true)
			{
				if (j1b1Text.getText() == null)
					j1b1Text.setText("Welcome");
				else
					j1b1Text.setName(null);
				
				Thread.sleep(200);
			}
		}
		catch(InterruptedException e) {}
	}
}

//改写 TaskThreadDemo.java
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorDemo 
{
	public static void main(String[] args)
	{
		//Create a fixed thread pool with maximum three threads
		ExecutorService executor = Executors.newFixedThreadPool(3);
		
		//Submit runnable tasks to the executor
		executor.execute(new PrintChar('a', 100));
		executor.execute(new PrintChar('b', 100));
		executor.execute(new PrintNum(100));
		
		//Shut down the executor
		executor.shutdown();
	}
}
class PrintChar implements Runnable
{
	//The task for printing a character a specified number of times
	private char charToPrint; //The character to print
	private int times;// The number of times to repeat
	
	//Construct a task with specified character and number of times to print the character
	public PrintChar(char c, int t)
	{
		charToPrint = c;
		times = t;
	}
	
	//Override the run() method to tell the system what task to perform
	public void run()
	{
		for (int i = 0; i < times; i++)
			System.out.print(charToPrint);
		System.out.println();
	}
}

//The task for printing numbers from 1 to n for a giving n
class PrintNum implements Runnable
{
	private int lastNum;
	
	//Construct a task for printing 1, 2, 3, ..., n
	public PrintNum(int n)
	{
		lastNum = n;
	}
	
	//Tell the thread how to run
	public void run()
	{
		for (int i = 1; i <= lastNum; i++)
			System.out.print(" " + i);
		System.out.println();
	}
}
//如果需要为一个任务创建一个线程，就使用Thread类。如果需要为多个任务创建线程，最好使用线程池

//此例用于引入“竞争状态”和“线程安全的”这两个概念
//当所有线程同时访问同一个数据时，就会出现数据破坏的问题

import java.util.concurrent.*;
public class AccountWithoutSync 
{
	private static Account account = new Account();
	public static void main(String[] args)
	{
		ExecutorService executor = Executors.newCachedThreadPool();
		// Create and launch 100 threads
		for (int i = 0; i < 100; i++)
			executor.execute(new AddAPennyTask());
		executor.shutdown();
		
		while (!executor.isTerminated()) {}
		System.out.println("What is balance? " + account.getBalance());
	}
	
	// A thread for adding a penny to account
	private static class AddAPennyTask implements Runnable
	{
		public void run()
		{
			account.deposit(1);
		}
	}
	
	// An inner class for account
	private static class Account
	{
		private int balance = 0;
		public int getBalance()
		{
			return balance;
		}
		public void deposit(int amount)
		{
			int newBalance = balance + amount;
			// This delay is deliberately added to magnify the data-corruption problem and make it easy to see.
			try
			{
				Thread.sleep(5);
			}
			catch(InterruptedException e) {}
			balance = newBalance;
		}
	}
}

//使用显示锁来修改 AccountWithoutSync.java

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
public class AccountWithSyncUsingLock 
{
	private static Account account = new Account();
	public static void main(String[] args)
	{
		ExecutorService executor = Executors.newCachedThreadPool();
		// Create and launch 100 threads
		for (int i = 0; i < 100; i++)
			executor.execute(new AddAPennyTask());
		executor.shutdown();
		
		// Wait until all tasks are finished
		while (!executor.isTerminated()) {}
		System.out.println("What is balance? " + account.getBalance());
	}
	
	// A thread for adding a penny to account
	private static class AddAPennyTask implements Runnable
	{
		public void run()
		{
			account.deposit(1);
		}
	}
	
	// An inner class for account
	private static class Account
	{
		private static Lock lock = new ReentrantLock(); // Create a lock
		private int balance = 0;
		public int getBalance()
		{
			return balance;
		}
		public void deposit(int amount)
		{
			lock.lock(); // Acquire the lock
			try
			{
				int newBalance = balance + amount;
				
				// This delay is deliberately added to magnify the data-corruption problem and make it easy to see.
				Thread.sleep(5);
				
				balance = newBalance;
			}
			catch(InterruptedException e) {}
			finally
			{
				lock.unlock(); // Release the lock
			}		
		}
	}
}
// 对 lock() 的调用之后紧随一个  try-catch 块并且在 finally 子句中释放这个锁是比较好的写法，可以确保锁被释放
// 通常，使用 synchronized 方法或语句必使用相互排斥的显示锁简单些。然而，使用显示锁对同步具有状态的线程更加直观和灵活


import java.util.concurrent.*;
import java.util.concurrent.locks.*;
public class ThreadCooperation 
{
	private static Account account = new Account();
	public static void main(String[] args)
	{
		// Create a thread pool with two threads
		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(new DepositTask());
		executor.execute(new WithdrawTask());
		executor.shutdown();
		
		System.out.println("Thread 1\t\tThread 2\t\tBalance");
	}
	public static class DepositTask implements Runnable
	{
		public void run()
		{
			try
			{ // Purposely delay it to let the withdraw method proceed
				while(true)
				{
					account.deposit((int)(Math.random() * 10) + 1);
					Thread.sleep(1000);
				}
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}
	
	// A task for subtracting an amount from the account
	public static class WithdrawTask implements Runnable
	{
		public void run()
		{
			
		}
	}
	// An inner class for account
	private static class Account
	{
		private static Lock lock = new ReentrantLock(); // Create a lock
		
		// Create a condition
		private static Condition newDeposit = lock.newCondition();
		
		private int balance = 0;
		
		public int getBalance()
		{
			return balance;
		}
		
		public void withdraw(int amount)
		{
			lock.lock(); // Acquire the lock
			try
			{
				while (balance < amount)
				{//注意：此处的 while 语句如果换为 if语句，提款任务可能永久等待。如果使用循环语句，则提款任务可以有重新检验条件的机会。因此，应该在循环语句中测试条件
					System.out.println("\t\t\tWait for a deposit");
					newDeposit.await();
				}
				
				balance -= amount;
				System.out.println("\t\t\tWithdraw " + amount + "\t\t" + getBalance());
			}
			catch (InterruptedException e) {}
			finally
			{
				lock.unlock(); // Release the lock
			}
		}
		
		public void deposit(int amount)
		{
			lock.lock(); // Acquire the lock
			try
			{
				balance += amount;
				System.out.println("Deposit " + amount + "\t\t\t\t\t" + getBalance());
				
				// Signal thread waiting on the condition
				newDeposit.signalAll();
			}
			finally
			{
				lock.unlock();
			}
		}
	}		
}
// 一旦线程调用条件上的 await()，线程就进入等待状态，等待回复的信号。如果忘记对状态调用 signal() 或 signalAll()，那么线程就永远等待下去。
//条件由Lock对象创建。为了调用任意方法(例如，await()、signal()和signalAll()),必须首先拥有锁。如果没有获取锁就调用这些方法，会抛出IllegalMonitorStateException异常

//生产者 / 消费者问题的有关代码

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
public class ConsumerProducer 
{
	private static Buffer buffer =  new Buffer();
	public static void main(String[] args)
	{
		// Create a thread pool with two threads
		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(new ProducerTask());
		executor.execute(new ConsumerTask());
		executor.shutdown();
	}
	
	// A task for adding an int to the buffer
	private static class ProducerTask implements Runnable
	{
		public void run()
		{
			try
			{
				int i = 1;
				while (true)
				{
					System.out.println("Producer writes " + i);
					buffer.write(i++); // Add value to the buffer
					// Put the thread to sleep
					Thread.sleep((int)(Math.random()) * 10000);
				}
			}
			catch(InterruptedException e)
			{e.printStackTrace();}
		}
	}
	
	private static class ConsumerTask implements Runnable
	{
		public void run()
		{
			try
			{
				while (true)
				{
					System.out.println("\t\t\tConsumer reads " + buffer.read());
					// Put the thread into sleep
					Thread.sleep((int)(Math.random() * 10000));
				}
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}
	// An inner class for buffer
	private static class Buffer
	{
		private static final int CAPACITY = 1; // buffer size
		private java.util.LinkedList<Integer> queue = new java.util.LinkedList<Integer>();
		
		// Create a new lock
		private static Lock lock = new ReentrantLock();
		
		// Create two conditions
		private static Condition notEmpty = lock.newCondition();
		private static Condition notFull = lock.newCondition();
		
		public void write(int value)
		{
			lock.lock(); // Acquire the lock
			try
			{
				while (queue.size() == CAPACITY)
				{
					System.out.println("Wait for notFull condition");
					notFull.await();
				}
				queue.offer(value);
				notEmpty.signal(); // Signal notEmpty Condition
			}
			catch(InterruptedException e)
			{e.printStackTrace();}
			finally
			{
				lock.unlock();
			}
		}
		
		public int read()
		{
			int value = 0;
			lock.lock(); // Acquire the lock
			try
			{
				while (queue.isEmpty())
				{
					System.out.println("\t\t\tWait for notEmpty condition");
					notEmpty.await();
				}
				
				value = queue.remove();
				notFull.signal(); // Signal notFull condition
			}
			catch(InterruptedException e)
			{e.printStackTrace();}
			finally
			{
				lock.unlock(); // Release the lock
				return value;
			}
		}
	}
}

//使用锁和条件同步生产者和消费者线程。在这个程序中，同步已经在 ArrayBlockingQueue 中实现，所以无需进行手动编码
import java.util.concurrent.*;
public class ConsumerProducerUsingBlockingQueue 
{
	private static ArrayBlockingQueue<Integer> buffer = new ArrayBlockingQueue<Integer>(2);
	public static void main(String[] args)
	{
		// Create a thread pool with two threads
		ExecutorService executor = Executors.newFixedThreadPool(2);
		executor.execute(new ProducerTask());
		executor.execute(new ConsumerTask());
		executor.shutdown();
	}
	
	// A task for adding an int to the buffer
	private static class ProducerTask implements Runnable
	{
		public void run()
		{
			try
			{
				int i = 1;
				while (true)
				{
					System.out.println("Producer writes " + i);
					buffer.put(i++); // Add value to the buffer
					// Put the thread to sleep
					Thread.sleep((int)(Math.random()) * 10000);
				}
			}
			catch(InterruptedException e)
			{e.printStackTrace();}
		}
	}
	
	private static class ConsumerTask implements Runnable
	{
		public void run()
		{
			try
			{
				while (true)
				{
					System.out.println("\t\t\tConsumer reads " + buffer.take());
					// Put the thread into sleep
					Thread.sleep((int)(Math.random() * 10000));
				}
			}
			catch(InterruptedException e)
			{
				e.printStackTrace();
			}
		}
	}
}
//改写 AccountWithSyncUsingLock.java 中的 Account 内部类

// An inner class for account
	private static class Account
	{
		// Create a semaphore
		private static Semaphore semaphore = new Semophore(1);
		private int balance = 0;
		public int getBalance()
		{
			return balance;
		}
		public void deposit(int amount)
		{
			try
			{
				semaphore.acquire();
				int newBalance = balance + amount;
				
				// This delay is deliberately added to magnify the data-corruption problem and make it easy to see.
				Thread.sleep(5);
				
				balance = newBalance;
			}
			catch(InterruptedException e) {}
			finally
			{
				semaphore.release();
			}
		}
	}
	// 将release()方法放到finally子句中，可以确保即使发生异常也能最终释放该许可


NingLiu_
关注
专栏目录
[Java]线程的同步与锁
iteye_16791的博客
03-21 245
一、线程同步 线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。 例如：创建并启动100个线程，每个线程都向同一个账户里添加一便士。当所有数据源同时访问同一数据源时，就会出现数据破坏问题。 import java.util.concurrent.*; public class AccountWithoutSync{ private static Account acc...
Java多线程实践之—同步篇
Always_On_Way
08-18 1034
Java多线程实践之—同步篇
java 多线程控制练习题
weixin_39475445的博客
02-15 213
//AA打印5次，BB打印10次，CC打印15次 //接着同上 //来10轮 根据题目需要精准控制线程，使用Lock来实现 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; c...
java多线程
yansensensen的博客
04-06 257
多线程 Java内部支持多线程，即一个程序种运行多个任务。   线程: 一个程序可能包含多个并发执行的任务。线程是一个任务从头到尾的执行流。在java中每个任务都是runnable接口的一个实例，也称为可运行对象（runnable object）。线程本质上讲就是便于任务执行的对象。  任务就是对象。任务中的run()方法指明如何完成任务。Java虚拟机会自动调用该方法，无需特意调用它。直
Java语言描述进程基本概念
Java教师的博客
05-08 648
1  线程的异步性 线程的异步性是由于多个线程异步的并发修改同一数据引起的。以下代码创建了100个线程，每个线程异步的向account对象中增加1分钱，运行该程序会发现最终结果并非100，而且每次运行结果都不相同。通过该程序可使学生直观的观察到线程异步性的问题，教师 import java.util.concurrent.*; public class AccountWithoutSync
线程：Java多线程编程核心技术_完整版书上代码
02-18
本资源"线程：Java多线程编程核心技术_完整版书上代码"提供了一个关于Java多线程编程的实践案例集，便于读者深入理解和掌握这一技术。 首先，我们需要了解线程的基本概念。在计算机科学中，线程是进程内的一个独立...
读书笔记：图解Java多线程设计模式一书学习示例代码.zip
最新发布
07-25
读书笔记：图解Java多线程设计模式一书学习示例代码
Java多线程设计模式_清晰完整PDF版 Java多线程设计模式源代码
11-16
本资料集包含了清晰完整的PDF版书籍和源代码，为学习和理解Java多线程设计模式提供了丰富的素材。 首先，我们要理解多线程的核心概念。在Java中，线程是程序执行的最小单位，每个线程都有自己的程序计数器、虚拟机...
Java多线程编程实例全书随书代码.rar
07-10
通过这些知识点的学习和实践，初学者可以逐步掌握Java多线程编程的核心技术，从而更好地应对并发编程中的挑战。代码示例是理论知识的直观展示，可以帮助理解和巩固所学，所以书中提供的实例对初学者来说是非常宝贵的...
读书笔记：图解Java多线程设计模式修订版结城浩学习代码.zip
07-25
读书笔记：图解Java多线程设计模式修订版结城浩学习代码
键盘操作练习
fenger_c的博客
12-16 1292
public class TypeKey { public static void main(String[] args) { System.out.println("键盘练习（输入#结束程序）"); System.out.println("输入显示的字母（回车）\n"); Letter letter; letter = new Letter(); GiveLetterThr
线程的5种状态详解
热门推荐
老猫的博客
08-23 24万+
Java中的线程的生命周期大体可分为5种状态。 1.新建(NEW)：新创建了一个线程对象。 2.可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。 3.运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslic...
实验7 多线程与JDBC
你热爱世界，我热爱你
12-24 1669
实验七：多线程与JDBC1. 实验目的2. 实验要求1) 创建多线程2) 线程同步3) 多线程实现键盘操作练习4) 数据库编程 1. 实验目的 了解JAVA多线程编程的概念；熟悉创建多线程的两种方法；了解数据库编程的基本过程。 2. 实验要求 1) 创建多线程 创建2个线程，一个线程负责输出英文字母表，另一个线程负责输出希腊字母表。 要求： ①通过继承Thread类实现创建线程。 ②通过实现Runnable接口创建线程。 package t7_1; public
学习笔记 java多线程（四）线程间协作
weixin_30782293的博客
04-26 164
通过保证在临界区上多个线程的相互排斥，线程间可以完全避免竞争状态的发生，但是有时候还是需要线程之间的相互协作。使用条件（Condition）便于线程间通信。一个线程可以指定在某种条件下该做什么。标间是通过调用Lock对象的newCoditionn（）方法来实现线程之间的相互通信的。 一旦创建一个条件，就可使用...
Java 多线程编程 实验题
c_y_s_的博客
03-16 5991
Java 多线程编程 实验题 1.创建键盘操作练习 2.双线程猜数字 3.月亮围绕地球
Java必实验四：线程应用
qq_62215764的博客
03-28 1418
一、 实验目的 1.掌握Java程序设计中的线程同步等技术。 二、实验内容与要求 (1). 运行以下三个程序（每个程序运行10次），并对输出结果给出分析。 (2). 编写Java应用程序实现如下功能：第一个线程生成一个随机数，第二个线程每隔一段时间读取第一个线程生成的随机数，并判断它是否是奇数。要求采用实现Runnable接口和Thread类的构造方法的方式创建线程，而不是通过Thread类的子类的方式。在报告中附上程序截图、完整的运行结果截图和简要文字说明。（20分） (3). 编写Jav.
上海面试题总结3
wdx_1136346879的博客
01-09 651
上海面试题总结 1.int和integer的区别 Java中int和Integer 关系是比较微妙的。关系如下： 1.int 是基本的数据类型； 2.Integer 是int的封装类； 3.int 和Integer都可以表示某一个数值； 4.int 和Integer不能够互用，因为他们两种不同的数据类型； 2.Application类有什么用 他们都继承自 android.content.Cont...
13.9.1 实验一 键盘操作练习
aaaax11_11的博客
05-25 2593
实验目的：     掌握使用Thread的子类创建线程的方法Main.javapublic class Main { public static void main(String[] args) { System.out.println("键盘练习（输入#结束程序）"); System.out.printf("输入显示的字母（回车）\n"); ...
多线程练习
why
10-05 300
富而可求也，虽执鞭之士，吾亦为之。如不可求，从吾所好。——孔子《论语》 public static void main(String[] args) { Thread t = new my(); t.setName("实体店"); t.start(); Thread t1 = new my(); t1.setName("官网店"); t1.start();
Java多线程编程实战：代码示例与深度解析
"Java多线程编程示例代码，适合初学者学习，包含详细讲解和可运行的示例，由汪文君编写，属于IOProgramming系列。" 在Java编程中，多线程是一项核心技能，它允许多个任务在同一时间执行，提高了程序的效率和响应性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值