发表于： 2018-01-26 22:05:31
1 583
今天完成的事情：（一定要写非常细致的内容，比如说学会了盒子模型，了解了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,一天做完.
返回列表
评论