线程二

线程API线程相关的若干方法Thread.currentThread方法.Thread类的静态方法currentThread方法可以用来获取运行当前代码片段的线程Thread current = Thread.currentThread();获取线程相关信息的方法String getName();返回该线程的名称long getId();返回该线程的标识符int getPrior...

ya哥

314人浏览 · 2019-01-14 20:23:53

ya哥 · 2019-01-14 20:23:53 发布

线程API
线程相关的若干方法
Thread.currentThread方法
.Thread类的静态方法currentThread方法可以用来获取运行当前代码片段的线程
Thread current = Thread.currentThread();

获取线程相关信息的方法
String getName();返回该线程的名称
long getId();返回该线程的标识符
int getPriority:返回该线程的优先级
Thread.state getState:获取线程的状态
boolean isDaemon():测试当前线程是否为守护线程

测试currentThread()方法:
public static void main(String[] args) {
       System.out.println("运行main方法的线程是:"+Thread.currentThread());
       TestCurrent();
   }
   public static void TestCurrent() {
//   实现输出当前线程
       System.out.println("运行currentThread方法的线程是:"+Thread.currentThread());
   }

Thread[main,5,main]:表示当前线程的名字为main,优先级为5,当前线程的主线程为main

在内部类中查看当前线程.
System.out.println("运行main方法的线程是:"+Thread.currentThread());
       TestCurrent();
       Thread t = new Thread() {
           @Override
           public void run() {
               System.out.println("线程t"+Thread.currentThread());
               TestCurrent();
           }
       };
       t.start();

问题:测试线程的相关方法
String getName();返回该线程的名称
long getId();返回该线程的标识符
1.创建两个线程,输出默认的线程名和默认的ID
2.创建一个线程,设置线程的名字并输出线程名和默认的ID
Thread t1 = new Thread();
       System.out.println(t1.getName());
       System.out.println(t1.getId());
       System.out.println(t1.getState());
Thread t3 = new Thread("nihao");
       //t3.setName("t3的线程名");
       System.out.println(t3.getName());

线程的优先级:
.线程的切换是有线程的调度控制的,我们无法通过代理来干涉,但是我们可以通过提高线程
的优先级来最大程度的改善线程获取时间片的概率
线程的优先级被划分成1-10级,值分别是1-10,其中1最低,10最高,线程提供了3个常量表示
最低,最高一级默认值
Thread.MAX_PRIORITY    10
Thread.MIN_PRIORITY       1
Thread.NORM_PRIORITY   5

-void setPriority();
设置线程的优先级

守护线程
.守护线程与普通线程在表示上没有什么区别,我们只需要通过Thread提供的方法设定即可:
-void setDaemon(boolean);
-当参数为true的时候该线程为守护线程
.守护线程的特点:
当进程中只剩下守护线程时,所有的守护线程限制终止
.GC就是运行在守护线程上.

测试守护线程
问题:
1.使用内部类创建线程的方式创建线程d,该线程实现每隔0.1s输出字符串"后台进程"
2.设置线程d为守护线程
3.使main线程阻塞5s,然后输出字符串"main线程结束"
public static void main(String[] args) {
       Thread t = new Thread() {
           public void run() {
               while(true) {
                   int num = 100;
                   System.out.println(num);
//               使线程休眠0.1s
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
                   }
           }

       };
//       设置线程t为守护线程
       t.setDaemon(true);
//       main线程调用线程t
       t.start();
//       阻塞main线程5s
       try {
           Thread.sleep(1000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("main线程结束了");
   }

sleep方法:
Thread的静态方法sleep用于使当前线程进入阻塞状态
-static void sleep(long ms)
.该方法会使当前线程进入阻塞状态指定毫秒,当阻塞指定毫秒后,当前线程会重新进入
Runnable状态,等待分配时间片
.该方法声明抛出一个InterruptedException.所以在使用该方法时需要捕获这个异常

*(了解)
yield方法:
Thread的静态方法yield:
-static void yield()
.该方法用于使当前线程主动让出当次CPU时间片回到Runnable状态,等待分配时间片

join方法
Thread的方法join
.该方法用于等待当前线程结束
.该方法声明抛出异常InterruptedException

测试join方法
使用两个线程模拟图片下载的过程
1.创建线程t1,该线程模拟实现图片的下载过程,即在该线程中实现输出字符串
"t1:正在下载图片"+下载的百分数
2.创建线程t2,在该线程中,首先输出"t2:等待图片下载完毕";然后将t1线程作为t2的
子线程,最后输出"t2:显示图片"
3.启动线程
4.一定要t1先执行完,之后才会显示"t2:显示图片"
public static void main(String[] args) {
       Thread t1 = new Thread() {
           @Override
           public void run() {
               for (int i = 1; i <= 10; i++) {
                   System.out.println("t1正在下载图片:"+i*10+"%");
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               System.out.println("t1图片下载完毕");
           }
       };
       Thread t2 = new Thread() {
           @Override
           public void run() {
               System.out.println("等待图片下载完毕");
               try {
                   t1.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("t2:显示图片");
           }
       };
       t1.start();
       t2.start();
   }

多线程基础
线程同步
StringBuffer是同步的synchronized append();
StringBuilder不是同步的append();

.ArrayList与HashMap不是同步的
.Vector和HashTable是同步的

//       如何获取线程安全的集合
       Collections.synchronizedList(null);
//       如何获取线程安全的Map
       Collections.synchronizedMap(null);

重点(线程池)
线程池的作用
-控制线程数量(防止系统因过度开辟新线程导致的系统崩溃)
-重用线程(避免系统资源浪费,以及过度切换线程所带来的隐患)
.当一个程序中若创建大量线程,并在任何解释后销毁,会给系统带来过度消耗资源
以及过度切换线程所带来的危险,从而导致系统崩溃,为此我们使用线程池来解决这个问题

.使用ExecutorService提供的用于管理线程池的类
线程池的概念:首先创建一些线程,他们的集合称为线程池,当服务器收到一个客户请求后,
就从线程池中取出一个空闲的线程为之服务,服务完后不关闭该线程,而是将该线程还回到
线程池中

在线程池的编程模式下,任务是提交给整个线程池,而不是直接提交给某个线程,线程池在拿到
任务后,他就在内部找有无空闲的线程,再把任务交给内部某个空闲的线程

ps:一个线程同时只能执行一个任务,但是可以同时向一个线程池提交多个任务.

编程模式下创建一个线程池.
1.Executors.newFixedThreadPool(int nThreads);
创建一个可重用固定线程集合的线程池

2.Executors.newFixedThreadPool();
创建一个可根据需要创建新线程的线程池,但是在以前构造的线程可用时将重用他们

3.有界队列当有界队列也满了

测试使用ExecutorService实现线程池
1.线程池要执行的任务为每隔一秒输出当前线程的名字,总计输出10次
2.创建一个线程池,该线程池只有两个空闲线程
3.是线程池执行5次步骤一的的任务
public class TestExecutoService {
   public static void main(String[] args) {
//       2.创建一个线程池
       ExecutorService threadpool = Executors.newFixedThreadPool(2);
//       3.设置线程池要执行的任务
       for (int i = 0; i<5; i++) {
           Handle handle = new Handle();
           threadpool.execute(handle);
       }
   }
}

//1.创建handle类,实现runnable接口,创建要执行的任务
class Handle implements Runnable{

   @Override
   public void run() {
       String name = Thread.currentThread().getName();
       System.out.println("执行当前任务的线程为:"+name);
       for (int i = 1; i <= 10; i++) {
           System.out.println(name+":"+i);
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       System.out.println(name+":执行完毕");
   }

}

双缓冲队列:
BlockingQueue
.在多线程并发时,若需要使用队列,我们使用Queue,但是要解决一个问题就是同步,
同步操作会降低并发对于Queue

BlockingQueue内部使用两条队列,可以允许两个线程同时进行操作,在保证并发安全的同时
提高了队列的存储效率
Queue ----先进先出一端取出,一端存储

ArrayBlockingQueue:规定大小的BlockingQueue,其构造函数必须带一个int参数来指明
其大小,其所含的对象是以先入先出顺序排序的.

练习:
1.如何创建双缓冲序列
2.如何对双缓冲存取数据
public static void main(String[] args) {
       testPull();
   }
       public static void testOffer() {
//           创建指定大小的双缓冲序列
           BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(10);
//           使用offer方法向队列中添加元素
           for(int i = 0;i<20;i++) {
//               设置1秒超时.1s元素仍然没有入队到队列中,则返回false
               try {
                   boolean b = queue.offer(i,1,TimeUnit.SECONDS);
                   System.out.println("存入是否成功:"+b);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
//       因为双缓冲的大下为10,所以入队10个元素之后,则不能在原元素入队了

//       测试pull方法
       public static void testPull() {
           BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(10);
//           赋值
           for (int i = 0; i < 10; i++) {
               queue.offer(i);
           }
//           取值
           for (int i = 0; i < 20; i++) {
               try {
                   Integer num = queue.poll(1, TimeUnit.SECONDS);
                   System.out.println("元素:"+num);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }