java之JUC系列

java之JUC系列
java之JUC系列

J.U.C体系的主要大板块包含内容,如下图所示:

注意这个里面每个部分都包含很多的类和处理器,而且是相互包含,相互引用的,相互实现的。

说到J UC其实就是说java的多线程等和锁,前面说过一些状态转换,中断等,我们今天来用它的tools来实现一些有些小意思的东西,讲到其他内容的时候,再来想想这写tools 是怎么实现的。

tools是本文说要讲到的重点,而tools主要包含哪些东西呢:

Tools也包含了5个部分的知识:Executors、Semaphor、Exchanger、CyclicBarrier、CountDownLatch,其实也就是五个工具类,这5个工具类有神马用途呢,就是我们接下来要将的内容了。

Executors:

其实它主要用来创建线程池,代理了线程池的创建,使得你的创建入口参数变得简单,通过方法名便知道了你要创建的线程池是什么样一个线程池,功能大概是什么样的,其实线程池内部都是统一的方法来实现,通过构造方法重载,使得实现不同的功能,但是往往这种方式很多时候不知道具体入口参数的改变有什么意思,除非读了源码才知道,此时builder 模式的方式来完成,builder什么样的东西它告诉你就可以。

常见的方法有(都是静态方法):

1、创建一个指定大小的线程池,如果超过大小,放入blocken队列中,默认是LinkedBlockingQueue,默认的ThreadFactory为:Executors.defaultThreadFactory(),是一个Executors的一个内部类。

Executors.newFixedThreadPool(int)

内部实现是:

[java]view plaincopy

1.public static ExecutorService newFixedThreadPool(int nThreads)

{

2. return new ThreadPoolExecutor(nThreads, nThreads,

3. 0L, https://www.360docs.net/doc/976462937.html,LISECONDS,

4. new LinkedBlockingQueue

ble>());

5.}

2、创建一个指定大小的线程池,如果超过大小,放入blocken队列中,默认是LinkedBlockingQueue,自己指定ThreadFactory,自己写的ThreadFactory,必须implements ThreadFactory,实现方法:newThread(Runnable)。

Executors.newFixedThreadPool(int,ThreadFactory)

内部实现是:

[java]view plaincopy

1.public static ExecutorService newFixedThreadPool(int nThreads,

ThreadFactory threadFactory) {

2. return new ThreadPoolExecutor(nThreads, nThreads,

3. 0L, https://www.360docs.net/doc/976462937.html,LISECONDS,

4. new LinkedBlockingQueue

ble>(),

5. threadFactory);

6.}

3、创建线程池长度为1的,也就是只有一个长度的线程池,多余的必须等待,它和调用Executors.newFixedThreadPool(1)得到的结果一样:

Executors.newSingleThreadExecutor()

内部实现是:

[java]view plaincopy

1.public static ExecutorService newSingleThreadExecutor() {

2. return new FinalizableDelegatedExecutorService

3. (new ThreadPoolExecutor(1, 1,

4. 0L, https://www.360docs.net/doc/976462937.html,LISECONDS,

5. new LinkedBlockingQueue

e>()));

6.}

是不是蛮简单的,就是在变参数,你自己也可以new的。

4、和方法3类似,可以自定义ThreadFactory,这里就不多说了!

5、创建可以进行缓存的线程池,默认缓存60s,数据会放在一个SynchronousQueue上,而不会进入blocken队列中,也就是只要有线程进来就直接进入调度,这个不推荐使用,因为容易出问题,除非用来模拟一些并发的测试:

Executors.newCachedThreadPool();

内部实现为:

[java]view plaincopy

1.public static ExecutorService newCachedThreadPool() {

2. return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

3. 60L, TimeUnit.SECONDS,

4. new SynchronousQueue

>());

5.}

6、和方法5类似,增加自定义ThreadFactory

7、添加一个Schedule的调度器的线程池,默认只有一个调度:

Executors.newSingleThreadScheduledExecutor();

内部实现为(这里可以看到不是用ThreadPoolExector了,schedule换了一个类,内部实现通过ScheduledThreadPoolExecutor类里面的内部类ScheduledFutureTask来实现的,这个内部类是private,默认是引用不到的哦):

[java]view plaincopy

1.public static ScheduledExecutorService newSingleThreadScheduled

Executor() {

2. return new DelegatedScheduledExecutorService

3. (new ScheduledThreadPoolExecutor(1));

4.}

8、和7一样,增加自己定义的ThreadFactory

9、添加一个schedule的线程池调度器,和newFixedThreadPool有点类似:

Executors.newScheduledThreadPool();

内部代码为:

[java]view plaincopy

1.public static ScheduledExecutorService newScheduledThreadPool(i

nt corePoolSize) {

2. return new ScheduledThreadPoolExecutor(corePoolSize);

3.}

其实内部Exectors里面还有一些其他的方法,我们就不多说明了,另外通过这里,大家先可以了解一个大概,知道Exectors其实是一个工具类,提供一系列的静态方法,来完成对对应线程池的形象化创建,所以不用觉得很神奇,神奇的是内部是如何实现的,本文我们不阐述文章中各种线程池的实现,只是大概上有个认识,等到我们专门将Exector系列的时候,我们会详细描述这些细节。

OK,我们继续下一个话题:

Semaphor,这个鸟东西是敢毛吃的呢?

答:通过名字就看出来了,是信号量。

信号量可以干什么呢?

答:根据一些阀值做访问控制。

OK,我们这里模拟一个当多个线程并发一段代码的时候,如何控制其访问速度:[java]view plaincopy

1.import java.util.Random;

2.import java.util.concurrent.Semaphore;

3.

4.

5. public class SemaphoreTest {

6. private final static Semaphore MAX_SEMA_PHORE = new Semap

hore(10);

7. public static void main(String []args) {

8. for(int i = 0 ; i < 100 ; i++) {

9. final int num = i;

10. final Random radom = new Random();

11. new Thread() {

12. public void run() {

13. boolean acquired = false;

14. try {

15. MAX_SEMA_PHORE.acquire();

16. acquired = true;

17. System.out.println("我是线程:

" + num + " 我获得了使用权!" + DateTimeUtil.getDateTime());

18. long time = 1000 * Math.max(1, Ma

th.abs(radom.nextInt() % 10));

19. Thread.sleep(time);

20. System.out.println("我是线程:

" + num + " 我执行完了!" + DateTimeUtil.getDateTime());

21. }catch(Exception e) {

22. e.printStackTrace();

23. }finally {

24. if(acquired) {

25. MAX_SEMA_PHORE.release();

26. }

27. }

28. }

29. }.start();

30. }

31. }

32. }

这里是简单模拟并发100个线程去访问一段程序,此时要控制最多同时运行的是10个,用到了这个信号量,运行程序用了一个线程睡眠一个随机的时间来代替,你可以看到后面有线程说自己释放了,就有线程获得了,没释放是获取不到的,内部实现方面,我们暂时不管,暂时知道这样用就OK。

接下来:

Exchanger十个神马鬼东西呢?

答:线程之间交互数据,且在并发时候使用,两两交换,交换中不会因为线程多而混乱,发送出去没接收到会一直等,由交互器完成交互过程。

啥时候用,没想到案例?

答:的确很少用,而且案例很少,不过的确有这种案例,Exchanger

[java]view plaincopy

1.import java.util.concurrent.Exchanger;

2.

3.public class ExchangerTest {

4.

5. public static void main(String []args) {

6. final Exchanger exchanger = new Exchanger

ger>();

7. for(int i = 0 ; i < 10 ; i++) {

8. final Integer num = i;

9. new Thread() {

10. public void run() {

11. System.out.println("我是线程:

Thread_" + this.getName() + "我的数据是:" + num);

12. try {

13. Integer exchangeNum = exchanger.exchang

e(num);

14. Thread.sleep(1000);

15. System.out.println("我是线程:

Thread_" + this.getName() + "我原先的数据为:" + num + " , 交换

后的数据为:" + exchangeNum);

16. } catch (InterruptedException e) {

17. e.printStackTrace();

18. }

19. }

20. }.start();

21. }

22. }

23.}

这里运行你可以看到,如果某个线程和另一个线程传送了数据,它接受到的数据必然是另一个线程传递给他的,中间步骤由Exchanger去控制,其实你可以说,我自己随机取选择,不过中间的算法逻辑就要复杂一些了。

接下来:

CyclicBarrier,关卡模式,搞啥玩意的呢?

答:当你在很多环节需要卡住,要多个线程同时在这里都达到后,再向下走,很有用途。能否举个例子,有点抽象?

答:团队出去旅行,大家一起先达到酒店住宿,然后一起达到游乐的地方游玩,然后一起坐车回家,每次需要点名后确认相关人员均达到,然后LZ一声令下,触发,大伙就疯子般的出发了。

下面的例子也是以旅游的方式来呈现给大家:

[java]view plaincopy

1.import java.util.concurrent.BrokenBarrierException;

2.import java.util.concurrent.CyclicBarrier;

3.

4.public class BarrierTest {

5.

6. private static final int THREAD_COUNT = 10;

7.

8. private final static CyclicBarrier CYCLIC_BARRIER = new Cyc

licBarrier(THREAD_COUNT ,

9. new Runnable() {

10. public void run() {

11. System.out.println("======>我是导游,本次点名结

束,准备走下一个环节!");

12. }

13. }

14. );

15.

16. public static void main(String []args)

17. throws InterruptedException, BrokenBarrierException

{

18. for(int i = 0 ; i < 10 ; i++) {

19. new Thread(String.valueOf(i)) {

20. public void run() {

21. try {

22. System.out.println("我是线程:

" + this.getName() + " 我们达到旅游地点!");

23. CYCLIC_BARRIER.await();

24. System.out.println("我是线程:

" + this.getName() + " 我开始骑车!");

25. CYCLIC_BARRIER.await();

26. System.out.println("我是线程:

" + this.getName() + " 我们开始爬山!");

27. CYCLIC_BARRIER.await();

28. System.out.println("我是线程:

" + this.getName() + " 我们回宾馆休息!");

29. CYCLIC_BARRIER.await();

30. System.out.println("我是线程:

" + this.getName() + " 我们开始乘车回家!");

31. CYCLIC_BARRIER.await();

32. System.out.println("我是线程:

" + this.getName() + " 我们到家了!");

33. } catch (InterruptedException e) {

34. e.printStackTrace();

35. } catch (BrokenBarrierException e) {

36. e.printStackTrace();

37. }

38. }

39. }.start();

40. }

41. }

42.}

测试结果中可以发现,大家一起走到某个步骤后,导游说:“我是导游,本次点名结束,准备走下一个环节!”,然后才会进入下一个步骤,OK,这个有点意思吧,其实赛马也是这个道理,只是赛马通常只有一个步骤,所以我们还有一个方式是:

CountDownLatch的方式来完成赛马操作,CountDownLatch是用计数器来做的,所以它不可以被复用,如果要多次使用,就要从新new一个出来才可以。我们下面的代码中,用两组赛马,每组5个参与者来,做一个简单测试:

[java]view plaincopy

1.import java.util.concurrent.CountDownLatch;

2.

3.public class CountDownLatchTest {

4.

5. private final static int GROUP_SIZE = 5;

6.

7. public static void main(String []args) {

8. processOneGroup("分组1");

9. processOneGroup("分组2");

10. }

11.

12. private static void processOneGroup(final String groupName)

{

13. final CountDownLatch start_count_down = new CountDownLa

tch(1);

14. final CountDownLatch end_count_down = new CountDownLatc

h(GROUP_SIZE);

15. System.out.println("==========================>\n分组:

" + groupName + "比赛开始:");

16. for(int i = 0 ; i < GROUP_SIZE ; i++) {

17. new Thread(String.valueOf(i)) {

18. public void run() {

19. System.out.println("我是线程组:

【" + groupName + "】,第:" + this.getName() + " 号线程,我已经准备就绪!");

20. try {

21. start_count_down.await();//等待开始指令

发出即:start_count_down.countDown();

22. } catch (InterruptedException e) {

23. e.printStackTrace();

24. }

25. System.out.println("我是线程组:

【" + groupName + "】,第:" + this.getName() + " 号线程,我已执行完成!");

26. end_count_down.countDown();

27. }

28. }.start();

29. }

30. try {

31. Thread.sleep(1000);

32. } catch (InterruptedException e) {

33. e.printStackTrace();

34. }

35. System.out.println("各就各位,预备!");

36. start_count_down.countDown();//开始赛跑

37. try {

38. end_count_down.await();//等待多个赛跑者逐个结束

39. } catch (InterruptedException e) {

40. e.printStackTrace();

41. }

42. System.out.println("分组:" + groupName + "比赛结束!

");

43. }

44.}

有点意思哈,如果你自己用多线程实现是不是有点麻烦,不过你可以用Thread 的join方法来实现,也就是线程的发生join的时候,当前线程(一般是主线程)要等到对应线程执行完run方法后才会进入下一步,为了模拟下,我们也来玩玩:[java]view plaincopy

1.public class ThreadJoinTest {

2.

3. private final static int GROUP_SIZE = 5;

4.

5. public static void main(String []args) throws InterruptedEx

ception {

6. Thread []threadGroup1 = new Thread[5];

7. Thread []threadGroup2 = new Thread[5];

8. for(int i = 0 ; i < GROUP_SIZE ; i++) {

9. final int num = i;

10. threadGroup1[i] = new Thread() {

11. public void run() {

12. int j = 0;

13. while(j++ < 10) {

14. System.out.println("我是1号组线程:

" + num + " 这个是我第:" + j + " 次运行!");

15. }

16. }

17. };

18. threadGroup2[i] = new Thread() {

19. public void run() {

20. int j = 0;

21. while(j++ < 10) {

22. System.out.println("我是2号组线程:

" + num + " 这个是我第:" + j + " 次运行!");

23. }

24. }

25. };

26. threadGroup1[i].start();

27. }

28. for(int i = 0 ; i < GROUP_SIZE ; i++) {

29. threadGroup1[i].join();

30. }

31. System.out.println("-==================>线程组1执行完

了,该轮到俺了!");

32. for(int i = 0 ; i < GROUP_SIZE ; i++) {

33. threadGroup2[i].start();

34. }

35. for(int i = 0 ; i < GROUP_SIZE ; i++) {

36. threadGroup2[i].join();

37. }

38. System.out.println("全部结束啦!哈哈,回家喝稀饭!");

39. }

40.}

代码是不是繁杂了不少,呵呵,我们再看看上面的信号量,如果不用工具,自己写会咋写,我们模拟CAS锁,使用Atomic配合完成咋来做呢。也来玩玩,呵呵:[java]view plaincopy

1.import java.util.concurrent.atomic.AtomicInteger;

2.

3.public class ThreadWaitNotify {

4.

5. private final static int THREAD_COUNT = 100;

6.

7. private final static int QUERY_MAX_LENGTH = 2;

8.

9. private final static AtomicInteger NOW_CALL_COUNT = new Ato

micInteger(0);

10.

11. public static void main(String []args) throws InterruptedEx

ception {

12. Thread []threads = new Thread[THREAD_COUNT];

13. for(int i = 0 ; i < THREAD_COUNT ; i++) {

14. threads[i] = new Thread(String.valueOf(i)) {

15. synchronized public void run() {

16. int nowValue = NOW_CALL_COUNT.get();

17. while(true) {

18. if(nowValue < QUERY_MAX_LENGTH && NOW_C

ALL_https://www.360docs.net/doc/976462937.html,pareAndSet(nowValue, nowValue + 1)) {

19. break;//获取到了

20. }

21. try {

22. this.wait(1000);

23. } catch (InterruptedException e) {

24. e.printStackTrace();

25. }

26. nowValue = NOW_CALL_COUNT.get();//获取

一个数据,用于对比

27. }

28. System.out.println(this.getName() + "======

我开始做操作了!");

29. try {

30. Thread.sleep(1000);

31. } catch (InterruptedException e) {

32. e.printStackTrace();

33. }

34. System.out.println(this.getName() + "======

操作结束了!");

35. NOW_CALL_COUNT.getAndDecrement();

36. this.notify();

37. }

38. };

39. }

40. for(int i = 0 ; i < THREAD_COUNT ; i++) {

41. threads[i].start();

42. }

43. }

44.}

还是有点意思哈,这样写就是大部分人对while循环那部分会写晕掉,主要是要不断去判定和尝试,wait()默认是长期等待,但是我们不想让他长期等待,就等1s然后再尝试,其实例子还可以改成wait一个随机的时间范围,这样模拟的效果会更加好一些;另外实际的代码中,如果获取到锁后,notify 方法应当放在finally中,才能保证他肯定会执行notify这个方法。

JAVA经典算法案例

JA V A经典算法40例 【程序1】题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第四个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 1.程序分析:兔子的规律为数列1,1,2,3,5,8,13,21.... public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 或 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=1;i<=20;i++) System.out.println(mymath.f(i)); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 【程序2】题目:判断101-200之间有多少个素数,并输出所有素数。 1.程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除, 则表明此数不是素数,反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % i==0 ) return false; return true; } } 【程序3】题目:打印出所有的"水仙花数",所谓"水仙花数 "是指一个三位数,其各位数字立方和等于该数本身。例如:153是一个"水

如何开展好安全风险管理体系建设

如何开展好安全风险管理体系建设 《国家电网公司安全风险管理体系实施指导意见》 《实施指导意见》共5章25条,包括总则;教育培训;作业安全风险管理;企业安全风险管理;电网安全风险管理;阐述了国家电网公司安全风险管理体系建设的基本原则;强调了开展安全风险管理教育培训的重要性及主要内容;说明了作业层、企业层、网省公司及总部层开展风险管理的基本流程和内容。这标志着国家电网公司关于安全风险管理体系建设的一些重要问题,如基本原则、体系内容、工作机制、重点要求等,有了一个比较系统、科学的阐述,和实事求是的定位,对于公司各单位立足实际,正确理解和开展安全风险管理工作,具有指导作用。《实施指导意见》基本原则和思路可以概括为24个字6句话:“坚定方向、理清思路、分清层次、分清专业、弄懂会用、持续改进”。 那么我们如何根据《实施指导意见》开展好安全风险管理体系建设? 1、(首先我们要)坚定风险管理的发展方向。我们知道,安全管理的实质是风险管理,我们现阶段在公司系统中开展安全风险管理,实施危险源辨识、风险分析、风险评估、风险控制,逐步建立基于闭环过程管理的安全风险管理体系,(这个体系的建立)既是现代企业安全管理发展的必然方向,也是我们实现安全“可控、能控、在控”的客观要求。通过大力开展宣传动员和教育培训,使各级人员弄懂学会风险管理的基本知识,理解风险管理的意义、作用、内容和流程,(我们来看一线流程,风险管理体系建立的流程是这样的)(咱们珲春供电公司各项工作,我感到抓的特别紧也特别实,我们现在搞宣传培训,实际就是在做这项工作,通过学习和培训来提高我们自身安全风险分析能力和安全管理控制水平) 2、理清风险管理的工作思路。在这方面,我们要坚持“以人为本、实事求是、注重实效、稳步推进”的基本原则,还要贯彻“分专业、分层次、抓培训、理流程、建机制、抓落实”的工作思路,(为此我们要)高度重视安全风险管理教育培训工作,奠定安全风险管理的良好基础。 3、建立分层次的风险防控体系。(就是要)按照各自管理职责和工作特点,不同管理层次负责控制不同程度和类型的安全风险,逐级落实安全责任。(就是说一把手有一把手的挂历的安全风险,下面各部门有各部门管理的安全风险,班组长有班组长管理的安全风险,下面员工就是直接操作者邮资机的安全责任,逐级落实安全)责任具体来说,(我们在工作中要掌握好一个首要任务和一个目标,那么首要任务是什么那?)就是供电企业以防止电网大面积停电事故作为首要任务,(目标就是)重点防控大面积停电风险;(目标就是)无论供电企业也好、还是基建施工单位都要以提高员工安全意识和风险防范能力为目标,重点防控人身伤亡、设备损坏、供电中断事故风险;基层班组、工区、个人重点控制作业过程中的违章、误操作、人身伤害等各类作业安全风险。(你看这样层次就分清楚了) 4、建立分专业的风险防控体系。就是要发挥安全生产“三个组织体系”的共同作用(那三个体系那?安全保证体系、安全监督体系、安全责任体系)(通过发挥三个组织体系的共同作用)形成专业配合并各负其责的安全风险防控机制。各级安监部门牵头制定安全风险管理总体方案和工作计划,组织开展宣传培训和风险评估,监督落实风险防控措施;那么,调度、生产、营销、基建等部门要按照“谁主管,谁负责”原则,负责

Java经典算法大全

Java经典问题算法大全 /*【程序1】 题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 1.程序分析:兔子的规律为数列1,1,2,3,5,8,13,21.... */ package https://www.360docs.net/doc/976462937.html,.flywater.FiftyAlgorthm; public class FirstRabbit { public static final int MONTH = 15; public static vo id main(String[] args) { long f1 = 1L, f2 = 1L; long f; for(int i=3; i

JAVA算法100例_全源码

JA V A经典算法40题 【程序1】题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第四个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 1.程序分析:兔子的规律为数列1,1,2,3,5,8,13,21.... public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 或 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=1;i<=20;i++) System.out.println(mymath.f(i)); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 【程序2】题目:判断101-200之间有多少个素数,并输出所有素数。 1.程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除, 则表明此数不是素数,反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++) if(mymath.iszhishu(i)==true) System.out.println(i); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } public boolean iszhishu(int x) { for(int i=2;i<=x/2;i++) if (x % 2==0 ) return false; return true;

公司安全生产风险分级管控体系建设手册

晋能集团有限公司安全生产风险分级管控体系建设指南

二〇一七年四月 目录 1 范围................................................. - 4 -

2 规范性引用文件....................................... - 4 - 3 差不多要求........................................... - 4 -3.1成立组织机构........................................ - 4 -3.2实施全员培训........................................ - 5 - 3.3编写体系文件........................................ - 5 - 4.1风险点确定.......................................... - 5 -4.1.1风险点划分原则 .................................... - 5 -4.1.2风险点排查........................................ - 6 -4.2危险源辨识.......................................... - 7 -4.2.1辨识方法.......................................... - 7 -4.2.2辨识范围.......................................... - 7 -4.2.3 辨识内容......................................... - 8 -4.2.4 危害因素造成的事故类不及后果..................... - 8 - 4.3.2安全检查表分析法(SCL) .......................... - 13 - 5 风险评价............................................ - 17 -5.1 风险度(危险性).................................. - 17 -5.2 风险评价方法...................................... - 17 -

协同过滤推荐算法(java原生JDK实现-附源码地址)

协同过滤推荐算法(java原生JDK实现-附源 码地址) 一、项目需求 1.需求链接 https://https://www.360docs.net/doc/976462937.html,/getStart/information.htm?raceId=231522 2.需求内容 训练数据包含了抽样出来的一定量用户在一个月时间(11.18~12.18)之内的移动端行为数据(D),评分数据是这些用户在这个一个月之后的一天(12.19)

对商品子集(P)的购买数据。参赛者要使用训练数据建立推荐模型,并输出用户在接下来一天对商品子集购买行为的预测结果。 评分数据格式 具体计算公式如下:参赛者完成用户对商品子集的购买预测之后,需要将结果放入指定格式的数据表(非分区表)中,要求结果表名为:tianchi_mobile_recommendation_predict.csv,且以utf-8格式编码;包含user_id 和item_id两列(均为string类型),要求去除重复。例如: 评估指标 比赛采用经典的精确度(precision)、召回率(recall)和F1值作为评估指标。具体计算公式如下: 其中PredictionSet为算法预测的购买数据集合,ReferenceSet为真实的答案购买数据集合。我们以F1值作为最终的唯一评测标准。 二、协同过滤推荐算法原理及实现流程 1.基于用户的协同过滤推荐算法 基于用户的协同过滤推荐算法通过寻找与目标用户具有相似评分的邻居用户,通过查找邻居用户喜欢的项目,推测目标用户也具有相同的喜好。基于用户的协同过滤推荐算法基本思想是:根据用户-项目评分矩阵查找当前用户的最近邻居,利用最近邻居的评分来预测当前用户对项目的预测值,将评分最高的N 个项目推荐给用户,其中的项目可理解为系统处理的商品。其算法流程图如下图1所示。

java实现图论中的经典算法

1.最短路的笛杰斯特拉算法 /** * * @author Administrator */ //这个算法用来解决无向图中任意两点的最短路径,同时输出路径(起点到所有点的) public class MinPath { public static String dijkstra(int[][] W1, int start, int end) { System.out.println("起点:" + start + "终点:" + end); boolean[] isLabel = new boolean[W1[0].length];// 是否标号 int[] indexs = new int[W1[0].length];// 所有标号的点的下标集合,以标号的先后顺序进行存储,实际上是一个以数组表示的栈 int i_count = -1;// 栈的顶点 int[] distance = W1[start].clone();// v0到各点的最短距离的初始值 int index = start;// 从初始点开始 int presentShortest = 0;// 当前临时最短距离 indexs[++i_count] = index;// 把已经标号的下标存入下标集中 isLabel[index] = true; while (i_count < W1[0].length) { // 第一步:得到与原点最近的某个点 int min = Integer.MAX_V ALUE; for (int i = 0; i < distance.length; i++) { if (!isLabel[i] && distance[i] != -1 && i != index) { // 如果到这个点有边,并且没有被标号 if (distance[i] < min) { min = distance[i]; index = i;// 把下标改为当前下标 } } } i_count = i_count + 1; if (i_count == W1[0].length) { break; } isLabel[index] = true;// 对点进行标号 indexs[i_count] = index;// 把已经标号的下标存入下标集中 if (W1[indexs[i_count - 1]][index] == -1 || presentShortest + W1[indexs[i_count - 1]][index] > distance[index]) { // 如果两个点没有直接相连,或者两个点的路径大于最短路径 presentShortest = distance[index]; } else { presentShortest += W1[indexs[i_count - 1]][index];

JAVA经典算法

河内塔问题(Towers of Hanoi) 问题说明: 河內之塔(Towers of Hanoi)是法国人M.Claus(Lucas)於1883年从泰国带至法国的,河內为越战时北越的首都,即现在的胡志明市;1883年法国数学家 Edouard Lucas曾提及這个故事,据说创世紀时Benares有一座波罗教塔,是由三支钻石棒(Pag)所支撑,开始时神在第一根棒上放置64个由上至下依由小至大排列的金盘(Disc),並命令僧侣将所有的金盘从第一根石棒移至第三根石棒,且搬运过程中遵守大盘子在小盘子之下的原则,若每日仅搬一个盘子,则当盘子全数搬运完毕之时,此塔将损毁,而也就是世界末日來临之时。 算法代码(Java): 复制内容到剪贴板 import java.io.*; public class Hanoi { public static void main(String args[]) throws IOException { int n; BufferedReader buf; buf = new BufferedReader(new InputStreamReader(System.in)); System.out.print("请输入盘子个数"); n = Integer.parseInt(buf.readLine()); Hanoi hanoi = new Hanoi(); hanoi.move(n, 'A', 'B', 'C'); } public void move(int n, char a, char b, char c) { if(n == 1) System.out.println("盘 " + n + " 由 " + a + " 移至 " + c); else { move(n - 1, a, c, b); System.out.println("盘 " + n + " 由 " + a + " 移至 " + c); move(n - 1, b, a, c);

安全生产风险管理体系基础知识手册

凯里供电局安全生产风险管理体系基础知识手册 一、通用部分 1、我们的安全理念是什么? 答:一切事故都可以预防。 2、南方电网公司有关风险体系建设的指导性文件主要有哪些? 答:主要文件有《安全生产风险管理体系》、《安全生产风险管理体系审核指南》、《安全生产风险管理体系建设与实施指导文件汇编》。3、安全生产风险管理体系的特点有哪些什么? 答:以风险控制为导向,强调事前的分析与控制; 以PDCA闭环管理为原则,强调工作的计划性、有效性能; 以系统化、规范化为管理思想,强调管理工作的系统性、管理过程的规范性; 以持续改进为目标,不断提高电网安全生产的绩效; 以先进管理体系为基础,突出专业化特色,实现了管理创新。 4、安全生产风险管理体系解决了什么问题? 答:解决安全生产“管什么,怎么管,做什么,怎么做”的问题,从管理理念、内容和方法上确保安全生产风险可控与在控。 5、安全生产“三大敌人”是什么? 答:违章、麻痹、不负责任。 6、安全生产风险管理体系建设与实施有哪些重要意义? 答:安全生产风险管理体系,强调系统的过程管理与结果管理并重,

关注事前的风险分析与评估,超前控制风险,把安全防范关口前移,持续、系统地改进安全生产管理,提升企业安全管理水平,促进企业持续、健康、科学的发展。 7、安全生产风险管理体系有哪几个单元?共有多少个要素? 答:南方电网公司安全生产风险管理体系共有九个单元。共有51个要素。 8、在安全生产风险管理体系推行过程中应注意做好哪“三个结合”、充分发挥哪“三种人”的作用?实现“两个控制”? 答:“三个结合”即安全生产风险管理体系与实际工作相结合。安全生产风险管理体系与生产管理规范化建设相结合。安全生产风险管理体系与本单位管理现状相结合。“三种人”是领导、中层干部、骨干。“两个控制”是质量、进度控制。 9、安全生产风险管理体系建设原则是什么? 答:1.基于风险的原则;2.事故/事件预先控制的原则;3.系统性原则;4.全员参与的原则;5.安全行为与态度的原则;6.持续改进的原则。 10、安全生产监督体系包括哪些? 答:安全生产监督体系包括安全监督部门、车间(分县局)安全专责、班组(站、所)安全员组成三级安全监督网络。 11、哪些变化可能给企业带来风险? 答:法律、法规、规程、标准或规章制度引起的变化;企业机构引起的变化;流程的变化;人员引起的变化;作业环境引起的变化;电网结构

java程序员必知的十种程序算法

java程序员必学的十种程序算法 算法1:快速排序算法 快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下,排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较,但这种状况并不常见。事实上,快速排序通常明显比其他Ο(n log n) 算法更快,因为它的内部循环(inner loop)可以在大部分的架构上很有效率地被实现出来。 快速排序使用分治法(Divide and conquer)策略来把一个串行(list)分为两个子串行(sub-lists)。 算法步骤: 1 从数列中挑出一个元素,称为“基准”(pivot),

2 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。 3 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。 递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会退出,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。 算法2:堆排序算法

堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。 堆排序的平均时间复杂度为Ο(nlogn) 。 算法步骤: 创建一个堆H[0..n-1] 把堆首(最大值)和堆尾互换 3. 把堆的尺寸缩小1,并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置 4. 重复步骤2,直到堆的尺寸为1 算法3:归并排序 归并排序(Merge sort,台湾译作:合并排序)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。 算法步骤:

安全风险分级管控体系建设实施计划方案

安全风险分级管控体系建设实施方案 编制: 审核: 批准: 建设集团股份有限公司 二0一七年六月

目录 1.适用范围------------------------------------------------------------------------------ 5 2.编制依据------------------------------------------------------------------------------ 5 3.总体要求、目标与原则--------------------------------------------------------------- 5 3.1总体要求 ------------------------------------------------------------------------- 5 3.2工作目标 ------------------------------------------------------------------------- 6 3.3基本原则 ------------------------------------------------------------------------- 6 4.职责分工------------------------------------------------------------------------------ 6 4.1领导小组 ------------------------------------------------------------------------- 6 4.2工作职责 ------------------------------------------------------------------------- 6 5.术语和定义 --------------------------------------------------------------------------- 7 5.1风险 ------------------------------------------------------------------------------ 7 5.2危险源---------------------------------------------------------------------------- 7 5.3风险点---------------------------------------------------------------------------- 8 5.4风险辨识 ------------------------------------------------------------------------- 8 5.5风险评估/评价------------------------------------------------------------------- 8 5.6风险分级 ------------------------------------------------------------------------- 8 5.7风险管控 ------------------------------------------------------------------------- 9 5.8风险信息 ------------------------------------------------------------------------- 9 5.9重大风险 ----------------------------------------------------------------------- 10 5.10重大危险源 ------------------------------------------------------------------- 10 6.风险点识别方法 -------------------------------------------------------------------- 10 6.1 风险点识别范围的划分要求--------------------------------------------------- 10 6.2 风险点识别方法 --------------------------------------------------------------- 10 7.风险评价方法----------------------------------------------------------------------- 10 8.风险控制措施策划------------------------------------------------------------------ 11 9.风险分级管控考核方法------------------------------------------------------------- 12 10.风险点识别及分级管控记录使用要求 -------------------------------------------- 12 附件: -------------------------------------------------------------------------------- 12

JAVA经典算法40题

JAVA经典算法40题 【程序1】题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第四个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 1.程序分析:兔子的规律为数列1,1,2,3,5,8,13,21.... public class exp2{ public static void main(String args[]){ int i=0; for(i=1;i<=20;i++) System.out.println(f(i)); } public static int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 或 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=1;i<=20;i++) System.out.println(mymath.f(i)); } } class math { public int f(int x) { if(x==1 || x==2) return 1; else return f(x-1)+f(x-2); } } 【程序2】题目:判断101-200之间有多少个素数,并输出所有素数。 1.程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除, 则表明此数不是素数,反之是素数。 public class exp2{ public static void main(String args[]){ int i=0; math mymath = new math(); for(i=2;i<=200;i++)

Java数据结构与经典算法——高手必会

1.大O表示法:粗略的量度方法即算法的速度是如何与数据项的个数相关的 算法大O表示法表示的运行时间 线性查找 O(N) 二分查找 O(logN) 无序数组的插入 O(1) 有序数组的插入 O(N) 无序数组的删除 O(N) 有序数组的删除 O(N) O(1)是最优秀的,O(logN)良好,O(N)还可以,O(N2)稍差(在冒泡法中见到) 2.排序 public class JWzw { //插入排序 public void insertArray(Integer []in){ int tem = 0; int num = 0; int upnum = 0; for (int i = 0; i < in.length; i++) { for (int j = i - 1; j >= 0; j--) { num++; if (in[j+1] < in[j]) { tem = in[j+1]; in[j+1] = in[j]; in[j] = tem; upnum++; } else { break; } } } for (int i = 0; i < in.length; i++) { System.out.print(in[i]); if(i < in.length - 1) { System.out.print(",");

} } System.out.println(); System.out.println("插入排序循环次数:" + num); System.out.println("移动次数:" + upnum); System.out.print("\n\n\n"); } //选择排序 public void chooseArray(Integer []in){ int tem = 0; int num = 0; int upnum = 0; for(int i = 0;i < in.length;i++) { for(int j = i;j < in.length - 1;j++){ num++; if(in[j+1] < in[j]){ tem = in[j+1]; in[j + 1] = in[j]; in[j] = tem; upnum++; } } } for (int i = 0; i < in.length; i++) { System.out.print(in[i]); if(i < in.length - 1) { System.out.print(","); } } System.out.println(); System.out.println("选择排序循环次数:" + num); System.out.println("移动次数:" + upnum); System.out.print("\n\n\n"); } //冒泡排序 public void efferArray(Integer []in){ int tem = 0; int num = 0; int upnum = 0;

安全风险分级管控体系建设

编号:SM-ZD-57139 安全风险分级管控体系建 设 Organize enterprise safety management planning, guidance, inspection and decision-making, ensure the safety status, and unify the overall plan objectives 编制:____________________ 审核:____________________ 时间:____________________ 本文档下载后可任意修改

安全风险分级管控体系建设 简介:该安全管理资料适用于安全管理工作中组织实施企业安全管理规划、指导、检查和决策等事项,保证生产中的人、物、环境因素处于最佳安全状态,从而使整体计划目标统一,行动协调,过程有条不紊。文档可直接下载或修改,使用时请详细阅读内容。 1.适用范围 本实施指南适用于山东宏升新型材料科技有限公司范围内的风险识别、评价、分级、管控。 编制依据 《中华人民共和共安全生产法》 《山东安全生产主体责任规定(修改稿)》(山东省人民政 府令20xx年第303号) 《机械行业较大危险因素辨识与防范指导手册》 《山东省人民政府办公厅关于建立完善风险管控和隐患排查 治理双重预防机制的通知》鲁安办发【2016】10号 其他安全生产相关法规、标准、相关政策以及山东宏升新型 材料科技有限公司安全生产管理制度等相关规定等要

求。 3.总体要求、目标与原则 根据上级政府主管部门的指示要求,结合山东宏升新型材料科技有限公司实际,公司着手建立安全风险分级管控体系建设。 3.1 总体要求:按照“全员参与,领导负责,职责明确,落实到位”的原则进行安全风险分级管控体系在建设。各部门在安全生产部的组织下按照《风险分级管控体系实施指南》建议编制大纲要求,结合各部门实际情况,严格落实,做到“全员、全过程、全方位、全天候”的风险管控模式。 3.2 工作目标:自本指南发布之日起,至20xx年9月份完成公司安全风险分级管控体系建设工作,同时,每三年开展一次风险分级工作,并通过建立风险管控体系做到有效遏制生产事故发生,保障员工生产财产安全。 3.3基本原则:坚持“统一指导、标杆示范、标准先行、分级推进,全面实施、持续改进“的基本原则,充分发挥各部门基层专业技术人员的主导作用,全面落实企主体责任。 4.职责分工

JAVA经典算法50题

【程序1】 题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少? 1.程序分析:兔子的规律为数列1,1,2,3,5,8,13,21.... public static void main(String[]args) { Scanner sc=new Scanner(System.in); System.out.println("请输入月数:"); int month=sc.nextInt(); int a=0,b=1,i,t; for(i=2;i<=month;i++) { t=b; b=a+b; a=t; } System.out.println("第"+month+"个月有"+b+"对兔子!"); } 【程序2】 题目:判断101-200之间有多少个素数,并输出所有素数。 1.程序分析:判断素数的方法:用一个数分别去除2到sqrt(这个数),如果能被整除, 则表明此数不是素数,反之是素数。 public static void main(String args[]) { int i,n,flag; for(n=101;n<200;n++) { flag=0; for(i=2;i

public static void main(String[]args)throws Exception { int i,j,count=0; for(i=101;i<200;i++) { for(j=2;j<(int)(Math.sqrt(i)+1);j++) { if(i%j==0) break; } if(j>(int)Math.sqrt(i)) { System.out.println(i); count++; } } System.out.println("201到200之间共有"+count+"个素数!"); } 【程序3】 题目:打印出所有的"水仙花数",所谓"水仙花数"是指一个三位数,其各位数字立方和等于该数本身。例如:153是一个"水仙花数",因为153=1的三次方+5的三次方+3的三次方。 1.程序分析:利用for循环控制100-999个数,每个数分解出个位,十位,百位。public static void main(String args[]) { int a,b,c; int n; for(n=100;n<1000;n++) { a=n/100; b=(n-a*100)/10; c=n%10; if(n==a*a*a+b*b*b+c*c*c) { System.out.println(n); } } } 【程序4】 题目:将一个正整数分解质因数。例如:输入90,打印出90=2*3*3*5。 程序分析:对n进行分解质因数,应先找到一个最小的质数k,然后按下述步骤完成: (1)如果这个质数恰等于n,则说明分解质因数的过程已经结束,打印出即可。 (2)如果n<>k,但n能被k整除,则应打印出k的值,并用n除以k的商,作为新的正整数你n,重复执行第一步。

安全生产风险管理体系建设心得体会

安全生产风险管理体系建设心得体会安全是公司的“生命线”,是一个企业赖以生存和发展的基石。随着社会主义市场经济的快速发展与物质文化生活水平的不断提高,安全问题日益凸显出来,给企业的安全管理提出了更新、更高的要求。如何做好电力正常供应,确保人身、电网、设备安全稳定,避免各类安全生产事故、事件的发生成为了目前供电企业安全管理面临的新课题。 什么是风险管理体系?就是我们一个企业为了控制风险,我们现在叫安全生产风险管理体系,那么我们就是为了控制安全生产风险,在企业内部所建立起来的一种运行的秩序或者叫机制。这种秩序机制表现形式就是我们企业的文件。没做它之前我们就有这些文件,我们的规章制度、操作规程等等,为什么还要去做?因为我们以前所存在的这种管理机制,没有充分把风险管理跟体系化的管理思想有效的融入,而我们现在建的这种机制就是要在原有机制的基础之上把风险管理跟体系化管理的思想进行一个有效的融入。那么以前没有融入风险管理思想,我们现在为什么要融入?风险管理的作用是什么?预控。那么在这里面实际上它的作用体现在就是完善我们原有的管理,我们基于风险辨识来进一步完善我们管理对象以及管理的流程节点,这是我们第一个作用。第二个作用是实现优化管理,表现形式就是差异化管理,风险管理最终一定要体现出所谓的差异化管理。我们为什么提出来风险管控要四分管控,分层、分级管控?所谓四分管控,分层、分级就是差异化管理,我们通过这种管理模式可以让我们提升管理的

针对性、有效性,可以降低我们的管理成本,优化我们的管理资源。这就是风险管理的最主要的两个目的。 安全生产风险管理体系简称“钻石体系”,共划分为18个星钻等级,等级的评审分为内审和外审,通过安全过程管理、工伤事故率、户均供电可靠率的指标完成情况,确定企业风险管理体系的最终评级。安全生产风险管理体系是一套完整的安全生产管理模式和方法,它体现了“一切事故都可以预防”的理念,结合了目前电力行业安全管理的实际,借鉴了传统安全管理的经验和方法,覆盖了安全生产管理整个过程,遵循PDCA的循环管理模式,以风险控制为主线,提出风险控制与管理内容,关注事前的风险分析与评估,将安全防范关口前移,从而实现动态的、主动的、超前的安全生产风险管理。它将安全管理划分为10个管理单元、52个管理要素以及多个管理节点和管理子标准,将风险管理引入企业的安全管理,一切从实际出发,进行危害辨识与风险评估,找出可能导致损失的风险,预先采取防范措施,不断预防和减少安全生产事故、事件的发生,推动安全生产管理向科学化、规范化、精细化和经济化迈进。 安全生产风险管理体系建设分为组织策划、教育培训、危害辨识与风险评估、体系文件编写、体系文件执行、内审、外审及修改完善八个步骤。安全生产风险管理体系建设是一项涉及面广、要求高、较为复杂的工作,需要广大干部员工的积极参与和密切配合。 第一,组织策划。体系的建设需要一套完整而实用的方案,制定培训计划,细化工作职责,明确周期目标,估算资金投入。方案的完

相关文档
最新文档