发表于: 2018-01-26 22:05:31

1 582


今天完成的事情:(一定要写非常细致的内容,比如说学会了盒子模型,了解了Margin) 

###25.07_多线程(线程组的概述和使用)(了解)
A:线程组概述
    * Java中使用ThreadGroup来表示线程组,它可以对一批线程进行分类管理,Java允许程序直接对线程组进行控制。
    * 默认情况下,所有的线程都属于主线程组。
        * public final ThreadGroup getThreadGroup()//通过线程对象获取他所属于的组
        * public final String getName()//通过线程组对象获取他组的名字
    * 我们也可以给线程设置分组
        * 1,ThreadGroup(String name) 创建线程组对象并给其赋值名字
        * 2,创建线程对象
        * 3,Thread(ThreadGroup?group, Runnable?target, String?name) 
        * 4,设置整组的优先级或者守护线程
    * B:案例演示
        * 线程组的使用,默认是主线程组

        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr, "张三");
        Thread t2 = new Thread(mr, "李四");
        //获取线程组
        // 线程类里面的方法:public final ThreadGroup getThreadGroup()
        ThreadGroup tg1 = t1.getThreadGroup();
        ThreadGroup tg2 = t2.getThreadGroup();
        // 线程组里面的方法:public final String getName()
        String name1 = tg1.getName();
        String name2 = tg2.getName();
        System.out.println(name1);
        System.out.println(name2);
        // 通过结果我们知道了:线程默认情况下属于main线程组
        // 通过下面的测试,你应该能够看到,默任情况下,所有的线程都属于同一个组
        System.out.println(Thread.currentThread().getThreadGroup().getName());

    * 自己设定线程组
*             
        // ThreadGroup(String name)
        ThreadGroup tg = new ThreadGroup("这是一个新的组");

        MyRunnable mr = new MyRunnable();
        // Thread(ThreadGroup group, Runnable target, String name)
        Thread t1 = new Thread(tg, mr, "张三");
        Thread t2 = new Thread(tg, mr, "李四");
        
        System.out.println(t1.getThreadGroup().getName());
        System.out.println(t2.getThreadGroup().getName());
        
        //通过组名称设置后台线程,表示该组的线程都是后台线程
        tg.setDaemon(true);


package com;

/**
* @author Arike
* Create_at 2018/1/26 16:21
*/
//线程组,如果没有给线程分组,默认是在main线程里面.
public class test23 {
public static void main(String[] args) {
ThreadGroup tg = new ThreadGroup("线程组1");
       System.out.println(new Thread(tg, () -> System.out.println(1), "线程1").getThreadGroup().getName());
       System.out.println(new Thread(tg, () -> System.out.println(2), "线程2").getThreadGroup().getName());
   }
}

###25.08_多线程(线程的五种状态)(掌握)
看图说话
新建,就绪,运行,阻塞,死亡

###25.09_多线程(线程池的概述和使用)(了解)
A:线程池概述
    * 程序启动一个新线程成本是比较高的,因为它涉及到要与操作系统进行交互。而使用线程池可以很好的提高性能,尤其是当程序中要创建大量生存期很短的线程时,更应该考虑使用线程池。线程池里的每一个线程代码结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用。在JDK5之前,我们必须手动实现自己的线程池,从JDK5开始,Java内置支持线程池
B:内置线程池的使用概述
    * JDK5新增了一个Executors工厂类来产生线程池,有如下几个方法
        * public static ExecutorService newFixedThreadPool(int nThreads)
        * public static ExecutorService newSingleThreadExecutor()
        * 这些方法的返回值是ExecutorService对象,该对象表示一个线程池,可以执行Runnable对象或者Callable对象代表的线程。它提供了如下方法
        * Future<?> submit(Runnable task)
        * <T> Future<T> submit(Callable<T> task)
    * 使用步骤:
        * 创建线程池对象
        * 创建Runnable实例
        * 提交Runnable实例
        * 关闭线程池
    * C:案例演示
        * 提交的是Runnable

        // public static ExecutorService newFixedThreadPool(int nThreads)
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 可以执行Runnable对象或者Callable对象代表的线程
        pool.submit(new MyRunnable());
        pool.submit(new MyRunnable());

        //结束线程池
        pool.shutdown();
        

package com;

import java.util.concurrent.*;

/**
* @author Arike
* Create_at 2018/1/27 10:14
*/
//线程池的测试.
//测试了有返回值的 Callable接口和Thread
public class test26 {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService et = Executors.newFixedThreadPool(5);
       et.submit(new Thread() {
@Override
           public void run() {
System.out.println("这是测试线程");
           }
});
       Future<Integer> fu = et.submit(() -> 2);
       
       System.out.println(fu.get());
       et.shutdown();
   }
}

###25.10_多线程(多线程程序实现的方式3)(了解)
提交的是Callable


        // 创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // 可以执行Runnable对象或者Callable对象代表的线程
        Future<Integer> f1 = pool.submit(new MyCallable(100));
        Future<Integer> f2 = pool.submit(new MyCallable(200));

        // V get()
        Integer i1 = f1.get();
        Integer i2 = f2.get();

        System.out.println(i1);
        System.out.println(i2);

        // 结束
        pool.shutdown();

        public class MyCallable implements Callable<Integer> {

            private int number;
        
            public MyCallable(int number) {
                this.number = number;
            }
        
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int x = 1; x <= number; x++) {
                    sum += x;
                }
                return sum;
            }
        
        }
多线程程序实现的方式3的好处和弊端
    * 好处:
        * 可以有返回值
        * 可以抛出异常
        
    * 弊端:
        * 代码比较复杂,所以一般不用明天计划的事情:(一定要写非常细致的内容) 


package com;

import java.util.concurrent.Callable;

/**
* @author Arike
* Create_at 2018/1/26 14:47
*/
//Callable是可以带返回值并且能够抛出异常的多线程.在需要在多线程完毕之后返回一个返回值的就可以用Callable.
public class test22 {
public static void main(String[] args) throws Exception {
((Callable<Integer>) () -> null).call();
       ((demo22) () -> null).ceshi();
       ((demo221) () -> System.out.println("测试")).ceshi();
       new Thread(() -> System.out.println("测试")).start();
       new Thread() {
@Override
           public void run() {
System.out.println("1111");
           }
}.start();
   }
}

interface demo22 {
Integer ceshi();
}

interface demo221 {
void ceshi();
}


另外又尝试了一波递归.

package com;

import java.math.BigInteger;

/**
* @author Arike
* Create_at 2018/1/26 21:37
*/
//使用递归和循环分别完成兔子函数(斐波那契函数)
   //对于性能这块儿,还是循环完胜.递归上百次就会造成内存溢出.(栈内存先进后出限制了递归的效率)
   //这就是为什么在windows删除多层(上百层)文件夹无法操作的原因,毕竟底层也是递归来完成.
public class test25 {
public static void main(String[] args) {
// System.out.println(run(4));
       int x = 9999;
       BigInteger smallbegin = new BigInteger("1");
       BigInteger bigend = new BigInteger("0");
       for (int i = 1; i < x; i++) {
BigInteger  temp = bigend;
           bigend = smallbegin.add(bigend);
           smallbegin = temp;
       }
System.out.println(bigend.add(smallbegin));
       //System.out.println(run(50));
   }

public static BigInteger run(int month) {
if (month < 3) {
return new BigInteger("1");
       } else {
return new BigInteger(run(month - 2).toString()).add(new BigInteger(run(month - 1).toString()));
       }
}
}


另外昨天花了几个小时学习如何使用git, 将自己的项目git到服务器上.


教程推荐廖雪峰的...


遇到的问题:(遇到什么困难,怎么解决的) 

在做递归的时候真的有点绕...


收获:(通过今天的学习,学到了什么知识)

多线程总算搞完了.... 明天好好做任务8,一天做完.



返回列表 返回列表
评论

    分享到