Java多线程基础

( 1 ) 传统使用类Thread和接口Runnable实现

1. 在Thread子类覆盖的run方法中编写运行代码

方式一

1new Thread(){ 
2 @Override  public void run(){
3   while(true){
4    try {
5     Thread.sleep(2000);
6         } catch (InterruptedException e) {
7     e.printStackTrace();
8         }
9      } 
10    }
11 }.start();

2. 在传递给Thread对象的Runnable对象的run方法中编写代码

1new Thread(new Runnable(){
2  public void run(){
3   while(true){
4    try {
5     Thread.sleep(2000);
6        } catch (InterruptedException e) {
7     e.printStackTrace();
8       } 
9   System.out.println(Thread.currentThread().getName());
10       }
11      }
12    }).start();

3. 总结

查看Thread类的run()方法的源代码，可以看到其实这两种方式都是在调用Thread对象的run方法，如果Thread
类的 run 方法没有被覆盖，并且为该 Thread 对象设置了一个 Runnable 对象，该 run 方法会调用 Runnable 对象的
run方法

1/**
2      * If this thread was constructed using a separate
3      * <code>Runnable</code> run object, then that
4      * <code>Runnable</code> object's <code>run</code> method is called;      
5      * otherwise, this method does nothing and returns.
6      * <p> 
7      * Subclasses of <code>Thread</code> should override this method.
8      *
9      * @see     #start() 
10      * @see     #stop()
11      * @see     #Thread(ThreadGroup, Runnable, String)
12      */
13     @Override
14     public void run() {
15         if (target != null) {
16             target.run();
17         } 
18    }

( 2 ) 定实现时器Timer和TimerTask
Timer 在实际开发中应用场景不多，一般来说都会用其他第三方库来实现.

1. 请模拟写出双重定时器

1要求：使用定时器,间隔 4 秒执行一次，再间隔 2 秒执行一次，以此类推执行。 
2 
3class TimerTastCus extends TimerTask{
4  @Override  public void run() {
5   count = (count +1)%2;
6   System.err.println("Boob boom ");
7   new Timer().schedule(new TimerTastCus(), 2000+2000*count);
8  }
9 }   
10 
11Timer  timer = new Timer();
12 timer.schedule(new TimerTastCus(), 2000+2000*count); 
13 
14while (true) {
15  System.out.println(new  Date().getSeconds());
16  try {
17   Thread.sleep(1000);
18  } catch (InterruptedException e) {
19   // TODO Auto-generated catch block
20   e.printStackTrace();
21  }
22 } 
23//PS：下面的代码中的 count 变量中
24 //此参数要使用在你匿名内部类中，使用 final 修饰就无法对其值进行修改，
25 //只能改为静态变量 private   static volatile int count  = 0;

( 3 ) 线程互斥与同步
在引入多线程后，由于线程执行的异步性，会给系统造成混乱，特别是在急用临界资源时，如多个线程急用同一台
打印机，会使打印结果交织在一起，难于区分。当多个线程急用共享变量，表格，链表时，可能会导致数据处理出错，
因此线程同步的主要任务是使并发执行的各线程之间能够有效的共享资源和相互合作，从而使程序的执行具有可再现性。

当线程并发执行时，由于资源共享和线程协作，使用线程之间会存在以下两种制约关系。
1. 间接相互制约。一个系统中的多个线程必然要共享某种系统资源，如共享 CPU，共享 I/O 设备，所谓间接相
互制约即源于这种资源共享，打印机就是最好的例子，线程 A在使用打印机时，其它线程都要等待。
2. 直接相互制约。这种制约主要是因为线程之间的合作，如有线程 A 将计算结果提供给线程 B 作进一步处理，
那么线程B 在线程 A将数据送达之前都将处于阻塞状态。
间接相互制约可以称为互斥，直接相互制约可以称为同步，对于互斥可以这样理解，线程 A 和线程 B 互斥访问某
个资源则它们之间就会产个顺序问题——要么线程 A 等待线程 B 操作完毕，要么线程 B 等待线程操作完毕，这其实就
是线程的同步了。因此同步包括互斥，互斥其实是一种特殊的同步。
( 4 ) 线程局部变量ThreadLocal

 ThreadLocal 的作用和目的：用于实现线程内的数据共享，即对于相同的程序代码，多个模块在同一个
线程中运行时要共享一份数据，而在另外线程中运行时又共享另外一份数据。
 每个线程调用全局 ThreadLocal 对象的 set 方法，在 set 方法中，首先根据当前线程获取当前线程的
ThreadLocalMap对象，然后往这个map中插入一条记录，key其实是ThreadLocal对象，value是各自的set
方法传进去的值。也就是每个线程其实都有一份自己独享的ThreadLocalMap对象，该对象的Key是ThreadLocal
对象，值是用户设置的具体值。在线程结束时可以调用ThreadLocal.remove()方法，这样会更快释放内存，不调
用也可以，因为线程结束后也可以自动释放相关的ThreadLocal变量。

在Runnable中创建ThreadLocal
在线程类内部创建ThreadLocal，基本步骤如下：
①、在多线程的类（如ThreadDemo类）中，创建一个ThreadLocal对象threadXxx，用来保存线程间
需要隔离处理的对象xxx。
②、在ThreadDemo类中，创建一个获取要隔离访问的数据的方法getXxx()，在方法中判断，若
ThreadLocal对象为null时候，应该new()一个隔离访问类型的对象，并强制转换为要应用的类型
③、在ThreadDemo类的run()方法中，通过调用getXxx()方法获取要操作的数据，这样可以保证每个线
程对应一个数据对象，在任何时刻都操作的是这个对象。

评论区

相关推荐