[ Java学习 ] 线程 书上代码

最新推荐文章于 2022-03-28 21:24:28 发布
最新推荐文章于 2022-03-28 21:24:28 发布
阅读量266 收藏
点赞数
分类专栏： 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_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程实例全书随书代码.rar
07-10
Java多线程编程实例全书随书代码，随书光盘源码，关于Java多线程编程方面的书籍源码，虽然年代久远了些，不过对于初学者来说，书中的例子还是很有代表性的，期待初学者一起学习研究。
[Java]线程的同步与锁
iteye_16791的博客
03-21 211
一、线程同步 线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。 例如：创建并启动100个线程，每个线程都向同一个账户里添加一便士。当所有数据源同时访问同一数据源时，就会出现数据破坏问题。 import java.util.concurrent.*; public class AccountWithoutSync{ private static Account acc...
Java多线程实践之—同步篇
Always_On_Way
08-18 990
Java多线程实践之—同步篇
实验7 多线程与JDBC
你热爱世界，我热爱你
12-24 1604
实验七：多线程与JDBC1. 实验目的2. 实验要求1) 创建多线程2) 线程同步3) 多线程实现键盘操作练习4) 数据库编程 1. 实验目的 了解JAVA多线程编程的概念；熟悉创建多线程的两种方法；了解数据库编程的基本过程。 2. 实验要求 1) 创建多线程 创建2个线程，一个线程负责输出英文字母表，另一个线程负责输出希腊字母表。 要求： ①通过继承Thread类实现创建线程。 ②通过实现Runnable接口创建线程。 package t7_1; public
[Java] 多线程和并行编程
学习笔记
05-11 1万+
目录 1  线程概念 2  创建任务和线程 3  Thread 类 4  例子：闪烁的文字 5  线程池 6  线程同步 6.1  使用synchronized关键字 6.2  Synchronizing Statement (同步语句) 7  使用锁进行同步 8  线程之间的合作 9 例子：生产者/消费者 10 阻塞队列 11 信号量 12 避免死锁 13 线程状态...
多线程练习
why
10-05 262
富而可求也，虽执鞭之士，吾亦为之。如不可求，从吾所好。——孔子《论语》 public static void main(String[] args) { Thread t = new my(); t.setName("实体店"); t.start(); Thread t1 = new my(); t1.setName("官网店"); t1.start();
JAVA上百实例源码以及开源项目源代码
09-17
　Java局域网通信——飞鸽传书源代码，大家都知道VB版、VC版还有Delphi版的飞鸽传书软件，但是Java版的确实不多，因此这个Java文件传输实例不可错过，Java网络编程技能的提升很有帮助。 Java聊天程序，包括服务端和...
java多线程tcpsocketserver源码-Java-Book:Java学习资料整理
06-05
Java学习资料整理 框架 / dubbo监控 / / / / / / / / / / / / / / / / / / / / 收藏 / 技术社区 书籍推荐 计算机基础 计算机科学导论 --(如果不是计算机科班的，应先看看计算机基础，了解一些基本概念，有助于之后的...
java多线程设计模式及源码
01-24
多线程与并发处理是程序设计好坏优劣的重要课题，本书通过浅显易懂的文字与实例来介绍JAVA线程相关的设计模式概念，并且通过实际的JAVA程序范例和UML图示来一一解说，书中有代码的重要部分加上标注使读者更加容易...
JAVA多线程实例 随书源码
05-27
关于JAVA多线程实例的一些源代码，大家可以学习学习，看看
学习笔记 java多线程（四）线程间协作
weixin_30782293的博客
04-26 158
通过保证在临界区上多个线程的相互排斥，线程间可以完全避免竞争状态的发生，但是有时候还是需要线程之间的相互协作。使用条件（Condition）便于线程间通信。一个线程可以指定在某种条件下该做什么。标间是通过调用Lock对象的newCoditionn（）方法来实现线程之间的相互通信的。 一旦创建一个条件，就可使用...
Java必实验四：线程应用
qq_62215764的博客
03-28 1311
一、 实验目的 1.掌握Java程序设计中的线程同步等技术。 二、实验内容与要求 (1). 运行以下三个程序（每个程序运行10次），并对输出结果给出分析。 (2). 编写Java应用程序实现如下功能：第一个线程生成一个随机数，第二个线程每隔一段时间读取第一个线程生成的随机数，并判断它是否是奇数。要求采用实现Runnable接口和Thread类的构造方法的方式创建线程，而不是通过Thread类的子类的方式。在报告中附上程序截图、完整的运行结果截图和简要文字说明。（20分） (3). 编写Jav.
键盘操作练习
fenger_c的博客
12-16 1233
public class TypeKey { public static void main(String[] args) { System.out.println("键盘练习（输入#结束程序）"); System.out.println("输入显示的字母（回车）\n"); Letter letter; letter = new Letter(); GiveLetterThr
Java上机实验 多线程
qq_45018803的博客
05-27 3186
目录实验1 键盘的操作练习实验2 双线程猜字 实验1 键盘的操作练习 TypeKey.java public class TypeKey { public static void main(String args[]){ System.out.println("键盘练习（输入#结束程序)"); System.out.println("输入显示的字母（回车)\n"); Letter letter; letter=new Letter(); GiveLetterThread giveCha
13.9.1 实验一 键盘操作练习
aaaax11_11的博客
05-25 2524
实验目的：     掌握使用Thread的子类创建线程的方法Main.javapublic class Main { public static void main(String[] args) { System.out.println("键盘练习（输入#结束程序）"); System.out.printf("输入显示的字母（回车）\n"); ...
上海面试题总结3
wdx_1136346879的博客
01-09 615
上海面试题总结 1.int和integer的区别 Java中int和Integer 关系是比较微妙的。关系如下： 1.int 是基本的数据类型； 2.Integer 是int的封装类； 3.int 和Integer都可以表示某一个数值； 4.int 和Integer不能够互用，因为他们两种不同的数据类型； 2.Application类有什么用 他们都继承自 android.content.Cont...
java多线程
yansensensen的博客
04-06 229
多线程 Java内部支持多线程，即一个程序种运行多个任务。   线程: 一个程序可能包含多个并发执行的任务。线程是一个任务从头到尾的执行流。在java中每个任务都是runnable接口的一个实例，也称为可运行对象（runnable object）。线程本质上讲就是便于任务执行的对象。  任务就是对象。任务中的run()方法指明如何完成任务。Java虚拟机会自动调用该方法，无需特意调用它。直
Java 多线程编程 实验题
c_y_s_的博客
03-16 5457
Java 多线程编程 实验题 1.创建键盘操作练习 2.双线程猜数字 3.月亮围绕地球
线程的5种状态详解
热门推荐
老猫的博客
08-23 23万+
Java中的线程的生命周期大体可分为5种状态。 1.新建(NEW)：新创建了一个线程对象。 2.可运行(RUNNABLE)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。 3.运行(RUNNING)：可运行状态(runnable)的线程获得了cpu 时间片（timeslic...
java多线程的文献的综述
最新发布
04-25
总之，Java多线程是Java程序中非常常见和重要的一部分，对于Java程序员来说学习和掌握Java多线程编程技术是非常有必要的。以上介绍的文献都是非常好的参考资料，可以帮助读者更深入地了解和掌握Java多线程编程相关...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值