黑马程序员_多线程

最新推荐文章于 2015-06-24 17:40:38 发布
最新推荐文章于 2015-06-24 17:40:38 发布
阅读量408 收藏
点赞数
分类专栏： Java 文章标签： java 多线程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013921901/article/details/22959449
版权
------- android培训、 java培训、期待与您交流！ ----------

1,对于多线程来说,首先要考虑的就是线程安全问题.

先来看一个卖票系统的例子,车站要卖100张票,有2个卖票窗口,

要解决线程安全问题就需要做到同步互斥.

把2个线程要访问的共享数据存放在一个类中,


注意:synchronized(x),锁的钥匙一定要用同一个,不然就是不同的锁,无法实现互斥的效果,

同一段代码中最好别出现2个锁,不然会造成死锁.

package cn.hmm.thread2;

//卖票系统,每个线程卖一张
public class ThreadSaletitck{
    
    public static void main(String[] args){
            res1 r = res1.get();
            Thread d1 = new Thread(new sale1(r));
            Thread d2 = new Thread(new sale2(r));
            d1.start();
            d2.start();
    }
}
//设计一个单例,用饿汉式
class res1{
      public int num = 100;
      public boolean flag = true;
      private res1(){
    	  
      }
      static res1 Obj = null;
      public static res1 get(){
    	  if(Obj==null){
    		  Obj = new res1();
    	  }
    	  return Obj;
      }
}


//售票站1
class sale1 implements Runnable
{
      private res1 r;
      sale1(res1 r){
              this.r = r;
      }
      public void run(){
    	  while(true){
    		  synchronized(r){
    	  			if(r.flag){
    	  				System.out.println("sale1 "+ r.num--);
    	  				r.flag = false;
    	  				if(r.num<=1)
    	  					return;
    	  			}
    		  }
    	  }
      }
}
//售票站2
class sale2 implements Runnable{
    private res1 r;
    sale2(res1 r){
            this.r = r;
    }
    public void run(){
  	  while(true){
  		  synchronized(r){
  			  if(!r.flag){
  				  System.out.println("sale2 "+ r.num--);
  				  r.flag = true;
  				  if(r.num<=1)
  					  return;
  			  }
  		  }
  	  }
    }
}

2,再来看一个例子:主线程先循环100次,然后再子线程循环10次,再主线程循环100次,子线程循环10次.....一直这样循环50次.

要解决这个问题也要用到同步互斥,可以把主线程循环100次和子线程循环10次写到2个方法上门,然后再封装到一个类中.

再创建出一个对象,调用这个对象上的2个方法.在这个类中用一个共享的布尔型变量作为标记,实现等待唤醒操作,代码如下:

package cn.hmm.thread;

public class TraditionalThreadCommunication {

	/**
	 * 主线程先循环50次,然后再子线程循环10次,再主线程循环50次,子线程循环10次.....
	 * 一直这样循环50次
	 * 
	 */
	public static void main(String[] args) throws InterruptedException {
		// TODO 自动生成的方法存根]
		final Business business = new Business();
		new Thread(new Runnable(){
			public void run(){
				for(int i=1;i<=50;i++){
					try {
						business.sun(i);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
				}
			}
		}).start();
		
		for(int i=1;i<=50;i++){
			business.main(i);
		}
	}

}

class Business{
	boolean bShouldSub = true;
	public synchronized void sun(int i) throws InterruptedException{
		while(bShouldSub){
			this.wait();
		}
			for(int j=1;j<=10;j++){
				System.out.println("sub thread:"+i+" loops:"+j);
			}
			bShouldSub = true;
			this.notify();
	}
	
	public synchronized void main(int i) throws InterruptedException{
		while(!bShouldSub){
			this.wait();
		}
			for(int j=1;j<=100;j++){
				System.out.println("main thread:"+i+" loops:"+j);
			}
			bShouldSub = false;
			this.notify();
	}

}


3,创建线程的传统方法:

package cn.hmm.thread;

public class TraditionalThread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		createThread1();
		
		createThread2();
		
		createThread3();
	}

	//子类的run()方法覆盖了父类的run()方法
	private static void createThread3() {
		new Thread(new Runnable(){
			public void run(){
				for(int i=0;i<99;i++){
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					System.out.println("Runnable:"+Thread.currentThread().getName());
				}
			}
		}){
			public void run(){
				for(int i=0;i<99;i++){
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					System.out.println("Thread:"+Thread.currentThread().getName());
				}
			}
		}.start();
	}

	//方法二:常用的方法
	private static void createThread2() {
		Thread thread2 = new Thread(new Runnable(){
			public void run(){
				for(int i=0;i<99;i++){
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName());					
				}
			}
		});
		thread2.start();
	}

	//方法一:不常用
	private static void createThread1() {
		Thread thread = new Thread(){
			public void run(){
				for(int i=0;i<99;i++){
					try {
						Thread.sleep(500);
					} catch (InterruptedException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName());
					//System.out.println(this.getName());
				}
			}
		};
		thread.start();
	}

}


4,定时器:

package cn.hmm.thread;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

//实现一次2秒一次4秒的交替,无限次的定时效果
class MyTimetTask extends TimerTask{
	private static int count = 0;
	public void run(){
		count = (count+1)%2;
		System.out.println("bombing!");
		new Timer().schedule(new MyTimetTask(), 2000+2000*count);
	}
}
public class TraditionalTimerTest {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//creatTimer1();
			creatTimer2();

	}
	//实现一次2秒一次4秒的交替,无限次的定时效果
	private static void creatTimer2() {
		new Timer().schedule(new MyTimetTask(), 2*1000);
		
		while(true){
			System.out.println(new Date().getSeconds());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		
}
	}
	
	@SuppressWarnings("deprecation")
	private static void creatTimer1() {
		new Timer().schedule(new TimerTask(){
			public void run(){
				System.out.println("bombing!");
			}
		}, 10*1000,3*1000);
		while(true){
			System.out.println(new Date().getSeconds());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}

}


5,线程内数据共享,各线程数据不受到影响:

package cn.hmm.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class ThreadScopeShareData {
	private static int data = 0;
	private static Map<Thread, Integer> threadData = new HashMap<Thread,Integer>();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		for(int i=0;i<2;i++){
			new Thread(new Runnable(){
				public void run(){
					data = new Random().nextInt(1000);
					System.out.println(Thread.currentThread().getName()+" data = "+data);
					threadData.put(Thread.currentThread(),data);
					new A().get();
					new B().get();
				}
			}).start();
		}
		
		/*new Thread(new Runnable(){
			public void run(){
				new A().get();
				new B().get();
			}
		}).start();*/
	}
	static class A{
		public void get(){
			int data = threadData.get(Thread.currentThread());
			System.out.println("A from "+Thread.currentThread().getName()+" get data:"+data);
		}
	}
	
	static class B{
		public void get(){
			int data = threadData.get(Thread.currentThread());
			System.out.println("B from "+Thread.currentThread().getName()+" get data:"+data);
		}
	}
}


package cn.hmm.thread;

import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class ThreadScopeShareData2 {
	private static int data = 0;
	private static Map<Thread, Integer> threadData = new HashMap<Thread,Integer>();
	/**
	 * @param args
	 */
	private static ThreadLocal<Integer> x = new ThreadLocal<Integer>();
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		
		for(int i=0;i<2;i++){
			new Thread(new Runnable(){
				public void run(){
					data = new Random().nextInt(1000);
					x.set(data);
					System.out.println(Thread.currentThread().getName()+" data = "+data);
					//threadData.put(Thread.currentThread(),data);
					new A().get();
					new B().get();
				}
			}).start();
		}
		
		/*new Thread(new Runnable(){
			public void run(){
				new A().get();
				new B().get();
			}
		}).start();*/
	}
	static class A{
		public void get(){
			//int data = threadData.get(Thread.currentThread());
			int data = x.get();
			System.out.println("A from "+Thread.currentThread().getName()+" get data:"+data);
		}
	}
	
	static class B{
		public void get(){
			//int data = threadData.get(Thread.currentThread());
			int data = x.get();
			System.out.println("B from "+Thread.currentThread().getName()+" get data:"+data);
		}
	}
}

6, JDK1.5的新特性 线程池:

package cn.hmm.thread2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//test1();
		test2();
		
	}


	private static void test2() {
		ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);
		threadPool.schedule(new Runnable(){
			public void run(){
				System.out.println("Bombing");
			}
		}, 
		10,
		TimeUnit.SECONDS);
		threadPool.shutdown();
		long start =System.currentTimeMillis();
		for(int i=0;i<20;i++){
			System.out.println(System.currentTimeMillis()-start);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		}
	}


	private static void test1() {
		//ExecutorService threadPool = Executors.newFixedThreadPool(3);//固定的线程池
		ExecutorService threadPool = Executors.newCachedThreadPool();//缓存的线程池
			for(int i=1;i<=10;i++){
				final int task =i;
				threadPool.execute(new Runnable(){
				public void run(){
					for(int j=1;j<=10;j++){
						try {
							Thread.sleep(20);
						} catch (InterruptedException e) {
							// TODO 自动生成的 catch 块
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName()+" is looping of "+j+" form task_"+task);
					}
				}
			});
		}
			System.out.println("all of 10 tasks have commotted!");
			threadPool.shutdown();
	}
	
}


7,模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。
修改程序代码，开四个线程让这16个对象在4秒钟打完。

package cn.hmm.thread2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {
	public static void main(String[] args){
        
		System.out.println("begin:"+(System.currentTimeMillis()/1000));
		/*模拟处理16行日志，下面的代码产生了16个日志对象，当前代码需要运行16秒才能打印完这些日志。
		修改程序代码，开四个线程让这16个对象在4秒钟打完。
		*/
		 ExecutorService threadPool = Executors.newFixedThreadPool(4);
		
		for(int i=0;i<16;i++){  //这行代码不能改动
			final String log = ""+(i+1);//这行代码不能改动
			{
				 threadPool.execute(new Runnable(){
					 public void run(){
						 Test.parseLog(log);
					 }
				 });	
				
			}
		}
	}
	
	//parseLog方法内部的代码不能改动
	public static void parseLog(String log){
		System.out.println(log+":"+(System.currentTimeMillis()/1000));
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
	}
}

总结:多线程并不能让程序运行的更快,但是多线程能让程序同时处理的事情变得更多,通过一些设计,可以让程序更快的完成任务.例如搜索用户磁盘中存在的文件.

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

详细请查看：www.itheima.com

你好hmm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员-多线程
Zhaoss_的博客
04-30 493
多线程的理解： 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位. 线程是进程的实体，一个线程可以创建和撤销另一个线程;同一个进程中的多个线程之间可以并发执行. 一个程序至少有一个进程,一个进程至少有一个线程；每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多
黑马程序员 多线程
u012034441的专栏
09-14 575
线程总结       java的特点之一就是内置对多线程的支持。多线程允许同时完成多个任务，使人产生多个任务在同时执行的错觉。其实目前是计算机的处理器在同一时刻只能执行一个线程，但处理器可以在不同的线程之间快速切换，切换速度远远超过人们接受信息的速度，所以感觉好像多个任务在同时执行。而c++没有内置多线程机制，必须调用底层的操作系统的多线程功能来进行多线程程序设计。       一、jav
黑马程序员_多线程_1
wu_zida的博客
06-24 349
进程：一个正在执行的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径或者控制单元线程：进程中一个独立的控制单元，线程控制着进程的执行一个进程至少有一个线程两种创建线程的方式： 一、 1、定义类，集成Thread 2、复写run方法，将自定义代码存储在run方法中，让线程运行 3、调用线程的start方法，该方法两个作用：启动线程，调用run方法二、 1、定义类实现Runnable
黑马程序员_张孝祥_Java多线程与并发库
05-17
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
根据给定文件的信息，我们可以提炼出以下关于Java多线程与并发库的相关知识点： ### Java多线程基础 1. **线程的概念**：在Java中，线程是程序执行流的基本单元。一个标准的Java应用程序至少有一个线程，即主...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景...因此，理解和掌握Java的多线程技术对于任何Java程序员来说都是至关重要的。
黑马程序员_多线程技术
yanghu612的专栏
06-16 571
名词解析： 进程：一个程序在内存中的所处空间。进程只分配应用程序的内存空间,并不执行应用程序。 线程：就是进程中一个负责程序执行中的控制单元(执行路径) 垃圾回收器：垃圾回收线程 当垃圾回收时会执行object的finalize方法,我们可以用system.gc()来通知垃圾回收线程要开始回收垃圾了。 并发：就是”同时”的意思 CPU执行资格：当某线程start()开启之后就有了CPU
黑马程序员_多线程socket聊天室
学习笔记
04-09 518
首先来jin分析一下几个小步骤：
流合并(把多个文件里面的内容写到一个文件里面)
u013921901的专栏
04-12 1328
[java] view plaincopy import java.io.*;   import java.util.*;      class SequenceDemo   {       public static void main(String[] args)throws IOException       {           Vector 
黑马程序员_考生成绩管理系统
u013921901的专栏
03-27 894
------- android培训、java培训、期待与您交流！ ----------　　 (1), 创建一个保存学生信息的Student类放在cn.hmm.domain包内. Student.java: [java] view plaincopy package cn.hmm.domain;      public clas
黑马程序员_面向对象总结
u013921901的专栏
04-08 644
------- android培训、java培训、期待与您交流！ ---------- ------- Windows Phone 7手机开发、.Net培训、期待与您交流！ ------- 详细请查看：www.itheima.com
黑马程序员_Java基础
u013921901的专栏
03-06 613
import java.util.*; /* * Set:元素是无序的,元素不可重复 * HsahSet:底层数据结构是哈希表 * HashSet是如何保证元素的唯一性的呢? * 是通过元素的两个方法,hashCode和equals来完成. * 如果元素的hashCode值不同,才会判断equals是否为true; **/ class HashSetDemo { pub
黑马程序员_Java概述
u013921901的专栏
03-05 610
package com.hmm; class Test2 { public static String getMaxSubString(String s1,String s2) { String max = "",min=""; max = s1.length()>s2.length()?s1:s2;//三目运算符 min = max == s1?s2:s1; sop("min
黑马程序员_集合总结
u013921901的专栏
03-09 606
port java.io.*; class TransStream { public static void main(String[] args)throws IOException { FileWrite(); } public static void FileWrite()throws IOException { //编码表不同,FileOutputStream能指定
黑马程序员_Java基础(2)
u013921901的专栏
03-06 586
import java.util.*; /* * TreeSet:可以对Set集合中的元素进行排序 * 往TreeSet集合中存储自定义对象学生,按照年龄排序 * 排序时,当主要条件相同时,一定要判断下次要条件. */ class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new T
黑马程序员_Java泛型
u013921901的专栏
03-30 560
/* 整个称为ArrayList泛型类型 ArrayList中的E称为类型变量或类型参数 整个ArrayList参数化的类型 ArrayList中的Integer称为类型参数的实例或实际类型参数 ArrayList中<>念typeof ArrayList称为原始类型 在创建数组实例时,数组的元素不能使用参数化的类型 Vertor vectorList[] = new Vecto
黑马程序员_7K月薪面试题破解之二_银行业务调度系统
u013921901的专栏
04-08 506
银行业务调度系统： 1. 业务需求： 模拟实现银行业务调度系统逻辑，具体需求如下：    1.1 银行内有6个业务窗口，1 - 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。    1.2 有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。    1.3 异步随机生成各种类型的客户，生成各类型用户的概率比例为：      
黑马程序员_Java反射技术
u013921901的专栏
03-29 500
反射构造函数:package cn.hmm; //反射构造函数 import java.lang.reflect.*; import java.util.*; public class reflectTest { public static void main(String[] args) throws Exception{ // TODO 自动生成的方法存根 //test1();
黑马程序员多线程练习题
最新发布
08-23
黑马程序员多线程练习题主要包括两个问题。第一个问题是如何控制四个线程在打印log之前能够同时开始等待1秒钟。一种解决思路是在线程的run方法中调用parseLog方法，并使用Thread.sleep方法让线程等待1秒钟。另一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值