今天上午考完了计算机二级，也算卸掉了一个大包袱吧，希望能过！（其实也就考着玩的，不来点考试就要发霉了）
好了，趁着难得的考后休息时间我就接着上一次没写完的继续更新吧。
上一篇文章——>Java核心之纷繁复杂的线程（一）,欢迎大家一起探讨呀。
上次我们讲到通过实现Runnable接口或是直接继承Thread类就可以自己创建线程了，这一次我们直接通过一些实战项目来练练手吧！
题目如下：
实现控制台购物车
实现ShoppingCart 。需要实现以下功能：
ShoppingCartItem属性有
private String name;// 商品名称
private double price;// 商品价格
private double num;// 商品数量
a.添加商品。向购物车中添加商品，如果商品已经存在，那么更新数量（原有数量+新数量）
b.更新购物车某一商品的数量。
c.删除已选购的某一商品
d.计算购物车中商品的总金额（商品×单价再求和）
代码：
package ShoppingCart;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 封装购物车处理的业务逻辑
*
* @author Administrator
*
*/
public class ShoppingCartBiz {
//String只是代号，与ShoppingCartItem中的值无关
private Map<String, ShoppingCartItem> map;
//封装的意义？
//这里封装就是为了减少不必要的对象创建，减少内存消耗
public ShoppingCartBiz() {
map = new HashMap<String, ShoppingCartItem>();
}
// private Map<String,ShoppingCartItem>map=
// new HashMap<String,ShoppingCartItem>();
/**
* 添加商品
* @param name
* @param price
*/
public void addItem(String name, double price) {
ShoppingCartItem item;
// ShoppingCartItem item=new ShoppingCartItem();
if (map.containsKey(name)) {// 商品已经购买过了
item = map.get(name);//为什么要赋值给item，难道item底层是数组
item.setNum(item.getNum() + 1);
} else {// 商品没有购买
item = new ShoppingCartItem();
item.setName(name);
item.setPrice(price);
item.setNum(1);
map.put(name, item);
}
}
/**
* 将所有商品存放到List中
* @return
*/
public List<ShoppingCartItem> toList(){
List<ShoppingCartItem> list=new ArrayList<ShoppingCartItem>();
//在这里new的list是指要新建一个list对象
//用泛型约束了其中的list保证该list对象是属于ShoppingCartItem类型的
for(String key:map.keySet()){
list.add(map.get(key));
//list啥都存是没设置泛型吗？
//这里的map.get(key)是指要传入对象
//至于对象里面的属性我们并不关心
}
return list;
}
}
package ShoppingCart;
/**
* 购物车商品项类
*
* @author Administrator
*
*/
public class ShoppingCartItem {
private String name;// 商品名称
private double price;// 商品价格
private int num;// 购买的商品数量
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}
测试类：
package ShoppingCart;
import java.util.List;
public class TestShoppingCartItem {
public static void main(String[] args) {
ShoppingCartBiz biz=new ShoppingCartBiz();
biz.addItem("华为手机", 1999);
biz.addItem("小米音响", 499);
biz.addItem("小米音响", 499);
List<ShoppingCartItem> list=biz.toList();
for(ShoppingCartItem item:list){
System.out.println(item.getName());
System.out.println(item.getPrice());
System.out.println(item.getNum());
}
}
}
这里还有几道题，虽然都是一些基础题，但我们可以通过不同的角度思考问题以形成一种发散式思维，这将大有裨益
package ShoppingCart;
public class ClimbThread implements Runnable {
private String name;
private int time;
private int number;
public ClimbThread(String name, int time, int number) {
this.name = name;
this.time = time;
this.number = number;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getTime() {
return time;
}
public void setTime(int time) {
this.time = time;
}
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public void run(){
for(int i=1;i<=this.number;i++){
try {
// Thread.currentThread().sleep(1000);
Thread.currentThread().sleep(this.time);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"已爬完第"+i+"个100米"
+"还剩"+(this.number-i)*100+"米");
if(i==this.number){
System.out.println(Thread.currentThread().getName()+"到达终点！");
}
}
}
}
package ShoppingCart;
public class TestClimbThread{
public static void main(String[] args) {
System.out.println("***********开始爬山***********");
ClimbThread cd=new ClimbThread("老年人",4000, 3);
ClimbThread cd2=new ClimbThread("年轻人",1000,20);
Thread t1=new Thread(cd);
Thread t2=new Thread(cd2);
t1.setName(cd.getName());
t2.setName(cd2.getName());
t1.start();
t2.start();
}
}
这个题目蛮有意思的，我在此提供了两种方法来解决这个问题
第一种
我们借用一下主线程即main()来实现多线程在同一方法类而可以调用join()来使当前线程直接进入等待状态，再插入另一个线程运行，直到指定的线程完成为止
package ThreadWork;
public class Registration implements Runnable {
@Override
public void run() {
for(int i=1;i<=20;i++){
System.out.println(Thread.currentThread().getName()
+":"+i+"号病人在看病……");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread t1=new Thread(new Registration());
t1.setName("特需号");
t1.start();
t1.setPriority(10);
Thread main=Thread.currentThread();
main.setName("普通号");
main.setPriority(5);
for(int i=1;i<=50;i++){
System.out.println(Thread.currentThread().getName()
+":"+i+"号病人在看病……");
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
if(i==10){
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
}
}
下面这种方法则是将mian()和线程创建方法分别设置
package ThreadWork;
/**
* 挂号看病
* @author Administrator
*
*/
public class CountNumb implements Runnable {
private int num;
private String name;
private int time;
public CountNumb(int num,String name,int time) {
this.num=num;
this.name=name;
this.time=time;
}
@Override
public void run() {
for (int i = 1; i <= this.num; i++) {
try {
Thread.sleep(time);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(this.name+":"+i+"号病人在看病");
if(this.name.equals("普通号") && i==10) {
try {
Thread.currentThread().join(3000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
package ThreadWork;
/**
* @author Administrator
*
*/
public class TestCountNumb {
public static void main(String[] args) {
CountNumb r1=new CountNumb(10,"特需号",500);
CountNumb r2=new CountNumb(50,"普通号",250);
Thread t1=new Thread(r1);
Thread t2=new Thread(r2);
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
虽然这种方法使代码看起来更加清爽，但却因为没法直接使用join()，只能变相地通过预估停止时间来实现目标方法，然而这是有风险的，而且操作上并不方便
所以还是建议使用第一种方法。
刚刚上面说到了线程的方法，既然说到了这里，我就总结一下主要的线程方法，当然这肯定不是所有的方法，想要所有方法的建议直接去看API
上图上图！
这里的一些方法我会下次单独讲一下详细的使用注意事项，就不在此赘述。
除了上面的一般简单使用外，线程还有一个非常重要的机制，那就是线程同步
在这里我们将引入一个新的专有名词——锁，(LOCK)
此时需要掌握的知识点
1、线程同步
使用synchronized修饰的方法控制对类成员变量的访问
synchronized就是为当前的线程声明一个锁
修饰方法：
访问修饰符 synchronized 返回类型 方法名（参数列表）{……}
或者
synchronized 访问修饰符 返回类型 方法名（参数列表）{……}
修饰代码块：
synchronized（锁对象）{}
这里我们直接看两个实战项目就比较好理解了
引入:
这里就是要防止黄牛抢太多的票，这里我用的是break跳出循环来实现黄牛线程的死亡，如果还有更好的方法欢迎评论留言
public class TicketGrabbing implements Runnable {
private String name;
public int count=10;
@Override
public void run() {
while(true){
synchronized(this){
if(count>0){
try {
Thread.currentThread().sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(Thread.currentThread().getName().equals("黄牛党")){
System.out.println(Thread.currentThread().getName()+
"抢到第"+(11-count)+"张票,剩余"+--count+"张票！");
break;
}
System.out.println(Thread.currentThread().getName()+
"抢到第"+(11-count)+"张票,剩余"+--count+"张票！");
}else{
break;
}
}
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class TestTicketGrabbing {
public static void main(String[] args) {
TicketGrabbing tc=new TicketGrabbing();
Thread t1=new Thread(tc,"桃跑跑");
Thread t2=new Thread(tc,"张票票");
Thread t3=new Thread(tc,"黄牛党");
t3.start();
t1.start();
t2.start();
}
}
下面是另一个题目，其实就是完成线程安全的实际操作
题目本身并不难，但却可以作为上手练习的好素材
代码部分:
public class RunningMan implements Runnable {
private String name;
@Override
public void run() {
synchronized(this){
System.out.println(Thread.currentThread().getName()+"拿到接力棒！");
for(int j=1;j<=10;j++){
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()
+"跑完了"+(j*10)+"米");
if(j==10){
break;
}
}
}
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class TestRunningMan {
public static void main(String[] args) {
RunningMan rm=new RunningMan();
for(int i=1;i<=10;i++){
Thread ti=new Thread(rm,i+"号");
ti.start();
try {
ti.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
好了，今天就讲这么多吧，其实每一次总结都要花费我一个多小时，不过这也是另一种学习过程，毕竟温故能知新嘛。
给出一张总结图，希望大家喜欢
回见