黑马程序员_线程并发库

最新推荐文章于 2024-01-17 09:45:23 发布
最新推荐文章于 2024-01-17 09:45:23 发布
阅读量338 收藏
点赞数
文章标签： 黑马程序员 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hx986853815/article/details/38140865
版权
------- android培训、java培训、期待与您交流！ ----------

JDK 1.5新特性 线程并发库：

    创建线程的两种传统方式：

        第一个创建线程思路：
            1.继承Thread类。
            2.覆盖Thread类中的run方法。
            3.把线程要运行的代码封装到run方法中。
            4.调用strat方法，开启一个线程并调用run方法。 

<span style="font-size:14px;color:#330033;"><span style="font-size:14px;">public class TraditionalThread {
    public static void main(String[] args) { 
	new Thread() { 
	    @Override
	    public void run() { 
		while (true) { 
		    try { 
			Thread.sleep(700); 
		    } catch (InterruptedException e) { 
			e.printStackTrace(); 
		    } 
		    System.out.println(this.getName()); 
		} 
	    } 
	}.start(); 
    }
}</span></span>
            第二中创建线程思路：
                1.实现Runnbale接口。
                2.覆盖Runnable接口的run方法。
                3.创建一个线程，把Runnable子类当成参数进行传递。
                4.把线程要运行的代码封装到Runnable子类的run方法中。
                5.调用线程的start方法，开启线程并调用run方法。 
<span style="font-size:14px;color:#330033;"><span style="font-size:14px;">public class TraditionalThread {
    public static void main(String[] args) { 
	new Thread(new Runnable(){ 
	    @Override
	    public void run(){ 
		while (true) { 
		    try { 
		        Thread.sleep(700); 
		    } catch (InterruptedException e) { 
			e.printStackTrace(); 
		    } 
	            System.out.println(Thread.currentThread().getName()); 
		} 
	    } 
        }).start(); 
    }
}</span></span>
    定时器的应用：   
<span style="font-size:14px;color:#330033;">import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class TraditionalTimerTest {
    private static int count = 0; 
    public static void main(String[] args) { 
	class MyTimerTask extends TimerTask{ 
	    @Override 
	    public void run() { 
		count = (count+1)%2; 
		System.out.println("bombing"); 
		new Timer().schedule(new MyTimerTask(),2000+2000*count ); 
	    } 
	} 
	new Timer().schedule(new MyTimerTask() ,2000); 
	while(true){ 
	    System.out.println(new Date().getSeconds()); 
	    try { 
		Thread.sleep(700); 
	    } catch (InterruptedException e) { 
		e.printStackTrace(); 
	    } 
	} 
    } 
}</span>
线程之间互斥：
 
<span style="font-size:14px;color:#330033;">public class TraditionalThreadSynchronized {
    public static void main(String[] args) { 
	new TraditionalThreadSynchronized().init();
    } 
    private void init(){ 
        final Outputer outputer = new Outputer(); 
	new Thread(){ 
	    public void run() { 
		while(true){ 
		    try { 
			Thread.sleep(500); 
		    } catch (InterruptedException e) { 
			e.printStackTrace(); 
		    } 
		    outputer.output("黑马程序员"); 
		} 
	    } 
        }.start(); 
	new Thread(){ 
	    public void run() { 
		while(true){ 
		    try { 
			Thread.sleep(500); 
		    } catch (InterruptedException e) { 
		        e.printStackTrace(); 
		    } 
		    outputer.output("黄兴"); 
		} 
	    } 
	}.start(); 
    } 
    static class Outputer{ 
	public void output(String name){ 
	    synchronized(""){ 
		for(int x=0;x<name.length();x++){ 
		    System.out.print(name.charAt(x)); 
                } 
		System.out.println(); 
	    } 
        } 
	public synchronized void output2(String name){ 
	    for(int x=0;x<name.length();x++){ 
		System.out.print(name.charAt(x)); 
	    } 
	    System.out.println(); 
	} 
	public static synchronized void output3(String name){ 
	    for(int x=0;x<name.length();x++){ 
		System.out.print(name.charAt(x)); 
	    } 
	    System.out.println(); 
	} 
    } 
}
//总结：线程之间的互斥就是在互斥的同步代码上加锁，锁可以是任意对象，但是必须保证锁的唯一。
</span>
线程之间的通讯：
 
public class TraditionalThreadCommunication {
    public static void main(String... args) { 
	final ThreadStartCode threadStartCode = new ThreadStartCode(); 
	new Thread(new Runnable(){ 
	    @Override 
		public void run() { 
		    for(int x=1;x<=50;x++){ 
			threadStartCode.sub(); 
		    } 
	        } 
	}).start(); 
	for(int x=1;x<=50;x++){ 
	    threadStartCode.main(); 
	} 
    } 
} 
class ThreadStartCode{
    private boolean falg = true; 
    public synchronized void sub(){ 
	while(!falg){ 
	    try { 
	        this.wait(); 
            } catch (InterruptedException e) { 
		e.printStackTrace(); 
	} 
    } 
        for(int x=1;x<=10;x++){ 
	    System.out.println(Thread.currentThread().getName()+"......sub..."+x); 
        } 
        falg = false; 
        this.notify(); 
    } 
    public synchronized void show(){ 
	while(falg){ 
	    try { 
		this.wait(); 
	    } catch (InterruptedException e) { 
		e.printStackTrace(); 
	} 
    } 
        for(int x=1;x<=10;x++){ 
	    System.out.println(Thread.currentThread().getName()+"......show..."+x); 
        } 
        falg = true; 
        this.notify(); 
    } 
}
//线程之间的通讯，就是Object任意对象的wait方法和notify方法。但是有一个前提就是要先有锁对象。
线程范围内的共享数据： 
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class ThreadSopeShareData {
    private static Map<Thread,Integer> map = new HashMap<Thread,Integer>(); 
    private static int data = 0; 
    public static void main(String[] args) { 
        for(int x=1;x<=2;x++){ 
	    new Thread(new Runnable(){ 
		@Override 
		public void run() { 
		    int data =new Random().nextInt(); 
		    map.put(Thread.currentThread(),data); 
		    System.out.println(Thread.currentThread().getName()+"...."+data); 
		    new A().get(); 
		    new B().get(); 
		} 
	    }).start(); 
	} 
    } 
    static class A{ 
	public void get(){ 
	    int data = map.get(Thread.currentThread()); 
	    System.out.println("A form "+Thread.currentThread().getName() +"...get data :"+data); 
	} 
    } 
    static class B{ 
        public void get(){ 
	    int data = map.get(Thread.currentThread()); 
	    System.out.println("B form "+Thread.currentThread().getName() +"...get data :"+data); 
	} 
    } 
}
//<span style="font-size:14px;">每个线程属于自己的线程数据，就是存进去的数据是存到线程中.</span><span style="font-size:14px;">当前线程去存入数据和取数据，取出来的数据是存入的数据.（不管是不是静态）</span>
线程范围内的共享数据，封装成对象。单例设计模式： 
import java.util.Random;

class Person{
    private static ThreadLocal<Person> threadLocal= new ThreadLocal<Person>();
    //单例模式（懒汉式）
    private String name;
    private int age;
    private Person(){}
        //这里是获取当前线程的实例对象。
    public static Person getInstance(){
    //由于的线程对象，所以必须保证每个线程对象都有一份 
        Person Instance =threadLocal.get();
	if(Instance == null){
	    synchronized (Person.class) {
		//判断对象是否为空
		if (Instance == null) {
		    //如果为空，则实例化该对象。
		    Instance = new Person();
	       	    //把对象设置进当前线程
		    threadLocal.set(Instance);
		}
	    }
        }
        //返回当前线程对象
        return Instance; 
    }
    public String getName() {
	return name;
    }
    public void setName(String name) {
	this.name = name;
    }
    public int getAge() {
	return age;
    }
    public void setAge(int age) {
	this.age = age;
    }
}
public class PersonThreadLocalTest {
    private static int date;
    public static void main(String[] args) {
	new PersonThreadLocalTest().intn();
    }
    public void intn(){
	for (int x = 1; x <= 5; x++) {
	    new Thread(new Runnable() {
		@Override
		public void run() {
		    int date = new Random().nextInt(11) + 13;
		    //获取当前线程的对象。 
		    Person p = Person.getInstance();
		    //给当前线程对象的age进行设置。
		    p.setAge(date);
		    //给当前线程对象的name进行设置。 
		    p.setName("黑马程序员——黄兴");
		    new A().getDate();
		    new B().getDate();
		}
	    //启动线程 
	    }).start();
	}
    }
    class A {
	public void getDate(){
            Person p = Person.getInstance();
	    System.out.println("A" + Thread.currentThread().getName() + "姓名：" + p.getName() + "年龄" + p.getAge());
	}
    }
    class B {
	public void getDate(){
	    Person p = Person.getInstance();
	    System.out.println("B" + Thread.currentThread().getName() + "姓名：" + p.getName() + "年龄" + p.getAge());
	}
    }
}
数据类型多线程并发操作： 
import java.util.concurrent.atomic.AtomicInteger;

public class atomicIntegerTest {
    public static void main(String... args) { 
	AtomicInteger atomicInteger =new AtomicInteger(); 
	atomicInteger.set(20); 
	atomicInteger.addAndGet(20); 
	System.out.println(atomicInteger); 
   } 
}
线程池： 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) { 
	ExecutorService executorService = Executors.newSingleThreadExecutor();//单一线程池 
	//Executors.newCachedThreadPool();//缓存线程池 
	//Executors.newFixedThreadPool(3);//固定大小线程池 
	for(int x=1;x<=10;x++){ 
	    final int task = x; 
	    executorService.execute(new Runnable(){ 
		@Override 
		public void run() { 
	            for(int y=1;y<=10;y++){ 
			System.out.println(Thread.currentThread().getName() +" is looping of "  + y +" for task of "+task ); 
		    } 
		} 
	    }); 
	} 
	System.out.println("over"); 
	//executorService.shutdown();//顺序关闭 
	//executorService.shutdownNow();//空闲时关闭线程池 
	//相当于TraditionThread的炸弹一样。 
	Executors.newScheduledThreadPool(3).schedule(new Runnable(){ 
	    public void run(){ 
		System.out.println("bombing"); 
	    } 
	},  
	5,  
	TimeUnit.SECONDS); 
	//连环爆炸。 
	Executors.newScheduledThreadPool(3).scheduleAtFixedRate(new Runnable(){ 
	    public void run(){ 
		System.out.println("bombing"); 
	    } 
	},  
	5,  
        2, 
	TimeUnit.SECONDS); 
    } 
}
------- android培训、java培训、期待与您交流！ ----------

hx986853815
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马程序员_张孝祥_Java多线程与并发库
05-17
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
黑马程序员_张孝祥_Java多线程与并发库 视频+代码+资料
10-29
根据给定文件的信息，我们可以提炼出以下关于Java多线程与并发库的相关知识点： ### Java多线程基础 1. **线程的概念**：在Java中，线程是程序执行流的基本单元。一个标准的Java应用程序至少有一个线程，即主...
黑马程序员_多线程与并发
hey_2的专栏
08-06 592
在过去单CPU时代，单任务在一个时间点只能执行单一程序。之后发展到多任务阶段，计算机能在同一时间点并行执行多任务或多进程。虽然并不是真正意义上的“同一时间点”，而是多个任务或进程共享一个CPU，并交由操作系统来完成多任务间对CPU的运行切换，以使得每个任务都有机会获得一定的时间片运行。 随着多任务对软件开发者带来的新挑战，程序不在能假设独占所有的CPU时间、所有的内存和其他计算机资源。一个好
黑马程序员_多线程
weixin_51429898的博客
01-17 1038
多线程的基础知识
黑马程序员_线程
liliangyzq的专栏
10-12 397
线程 什么是线程： 专业定义： 利用对象，可将一个程序分割成相互独立的区域。我们通常也需要将一个程序转换成多个独立运行的子任 务。 象这样的每个子任务都叫作一个“线程”（Thread）。编写程序时，可将每个线程都想象成独立运行，而且 都有自己的专用 CPU。一些基础机制实际会为我们自动分割 CPU 的时间。我们通常不必关心这些细节问题， 所以多线程的代码编写是相当简便的。
黑马程序员_线程概述
limumu100的专栏
06-23 367
多线程概述：   多线程好处：解决了多部分同时运行的问题。   多线程的弊端：线程太多回到效率的降低。   其实应用程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的。   JVM启动时就启动了多个线程，至少有两个线程可以分析的出来。   1，执行main函数的线程，   该线程的任务代码都定义在main函数中。   2，负责垃圾回收的线程      
黑马程序员__多线程
haojude的专栏
05-11 581
------http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1.线程是程序执行的一条路径, 一个进程中可以包含多条线程，多线程并发执行可以提高程序的效率, 可以同时完成多项工作。 2.开启新线程的两种方式  1).继承Thread
黑马程序员_java并发Executors
ck6102的专栏
07-24 556
并发就是一个时间段内有几个程序同时执行！那么java程序实现的并发我们经常使用多线程来表述！在java中要想实现多线程，有两种手段，一种是继续Thread类，另外一种是实现Runable接口。若是我们写的项目需要的线程少的话，这样写是完全可以的！那么要是需要很多很多大量的线程的话，我们在使用这样的方法就过于死板与复杂了！那么怎么办呢？当然我们考虑到的sun公司也考虑到了，在java5.0以后，su
Java黑马程序员-多线程笔记
luohanisme的博客
10-17 978
哔哩哔哩java黑马视频笔记
黑马程序员_并发库的应用
WhiteBlackSmith的专栏
07-22 360
计算机中把每一个执行中的程序都建立一个进程，
黑马程序员06_多线程并发库
黑马晓志的专栏
03-15 593
ThreadLocal实现线程范围内的共享变量，就是一个线程
黑马程序员–Java多线程讲解笔记
12-22
在一个进程中，可以有多个线程并发执行，这就是多线程。多线程的使用场景包括： 1. 并行处理，使得计算机可以同时处理多个任务，提高系统效率。 2. 后台运行，比如服务程序，可以在不影响用户界面的情况下运行。 3....
黑马程序员Javase笔记
01-18
"黑马程序员Javase笔记"是一个自学者在学习黑马程序员提供的Java全套课程过程中整理的笔记，主要涵盖了Java Standard Edition (Javase) 的核心内容。下面将详细讨论其中的关键知识点。 首先，DOS命令是操作系统中的...
多线程高新(黑马程序员)
04-03
在黑马程序员的课程中，可能涵盖了以上知识点的详细讲解，包括如何创建线程、使用线程池、处理并发异常、调试多线程程序以及相关工具的使用。通过学习这些内容，开发者能够掌握多线程编程的基本技能，提高软件的并发...
mediapipe-0.8.8.1-cp39-cp39-manylinux_2_17_x86_64.whl
08-11
mediapipe-0.8.8.1-cp39-cp39-manylinux_2_17_x86_64.whl
python爱心代码高级
08-11
1. 一行代码画爱心 print('\n'.join([''.join([('Love'[(x-y)%4]if((x*0.05)**2+(y*0.1)**2-1)**3-(x*0.05)**2*(y*0.1)**3<=0 else' ')for x in range(-30,30)])for y in range(15,-15,-1)])) 效果图 2. 用turtle库画爱心加文字 import turtle import math turtle.pen() t=turtle t.up() t.goto(0,150) t.down() t.color('red') t.begin_fill() t.fillcolor('red') t.speed(1) t.left(45) t.forward(150) t.right(45) t.forward(100) t.right(45) t.forward(100) t.right(45) t.forward(100) t.right(45) t.forward(250+math.sqrt(2)*100) t.right (90) t
mediapipe-0.8.9.1-cp38-cp38-win_amd64.whl
08-11
mediapipe-0.8.9.1-cp38-cp38-win_amd64.whl
开发资料技术资料USB设备驱动开发深度解析-宋宝华非常好的技术资料.zip
最新发布
08-11
开发资料技术资料USB设备驱动开发深度解析-宋宝华非常好的技术资料.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值