Sd - Java多线程

1. Java中线程有哪些同步的方法？

在Java语言中，每个对象都有一个锁，一个线程可以通过关键字synchronized来申请获取某个对象的锁，关键字synchronized可以被用于方法（粗粒度锁，对性能影响较大）或代码块（细粒度锁）级别。锁定方法往往不是一个很好的选择，取而代之的我们应该只锁定那些访问共享资源的代码块，因 为每一个对象都有一个锁，所以可以通过创建虚拟对象来实现代码块级别的同步，方法块级别的锁比锁定整个方法更有效。

 

 

 

 

Java虚拟机灵活的使用锁和监视器，一个监视器总体来说就是一个守卫者，他负责确保只有一个线程会在同一时间执行被同步的代码。每个监视器对应一个对象的引用， 在线程执行代码块的第一条指令之前，他必须持有该引用对象的锁，否则他将无法执行这段代码。一旦他获得锁，该线程就可以进入这段受到保护的代码。当线程不 论以何种方式退出代码块时，他都将释放关联对象的锁。对于静态方法，需要请求类级别的锁。

2. 解释实现多线程的几种方法

   继承Thread 类

   实现Runnable 接口

最好使用Runnable接口，这样你的类就不必继承Thread类，不然当你需要多重继承的时候，你将一筹莫展（我们都知道Java中的类只能继承自一个 类，但可以同时实现多个接口）。在上面的例子中，因为我们要继承Base类，所以实现Runnable接口成了显而易见的选择。同时你也要注意到在不同的 例子中，线程是如何启动的。按照面向对象的方法论，你应该只在希望改变父类的行为的时候才去继承他。通过实现Runnable接口来代替继承Thread 类可以告诉使用者Counter是Base类型的一个对象，并会作为线程执行。

3. Thread.start ()与 Thread.run ()有什么区别

4. Sleep ()、suspend ()和 wait ()之间有什么区别

5. 线程和进程的关系以及区别

　　

      进程和线程的关系：

    （1）一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

    （2）资源分配给进程，同一进程的所有线程共享该进程的所有资源。

    （3）处理机分给线程，即真正在处理机上运行的是线程。

    （4）线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步。线程是指进程内的一个执行单元,也是进程内的可调度实体.

      进程与线程的区别：

    （1）调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位

    （2）并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行

    （3）拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源.

    （4）系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。

      一个进程对应一个程序的执行，而一个线程则是进程执行过程中的一个单独的执行序列，一个进程可以包含多个线程。线程有时候也被称为轻量级进程.

 

      一个Java虚拟机的实例运行在一个单独的进程中，不同的线程共享Java虚拟机进程所属的堆内存。这也是为什么不同的线程可以访问同一个对象。线程彼此共 享堆内存并保有他们自己独自的栈空间。这也是为什么当一个线程调用一个方法时，他的局部变量可以保证线程安全。但堆内存并不是线程安全的，必须通过显示的声明同步来确保线程安全。

6. 进程间通信的方式

　　

    （1）管道（pipe）及有名管道（named pipe）：管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。

    （2）信号（signal）：信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效果上可以说是一致的。

    （3）消息队列（message queue）：消息队列是消息的链接表，它克服了上两种通信方式中信号量有限的缺点，具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息。

    （4）共享内存（shared memory）：可以说这是最有用的进程间通信方式。它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等。

    （5）信号量（semaphore）：主要作为进程之间及同一种进程的不同线程之间得同步和互斥手段。

    （6）套接字（socket）：这是一种更为一般得进程间通信机制，它可用于网络中不同机器之间的进程间通信，应用非常广泛。

7. 说明线程的状态

下图说明了线程的各种状态.

 

可执行(Runnable)：当调用start()方法后，一个线程变为可执行状态，但是并不意味着他会立刻开始真正地执行。而是被放入线程池，由线程调度器根据线程优先级决定何时挂起执行。

  1.MyThread aThread = newMyThread(); 2.aThread.start();                   //becomes runnable

 

执行中(Running)：处理器已经在执行线程的代码。他会一直运行直到被阻断，或者通过静态方法Thread.yield()自行放弃执行的机会，考虑到场景切换所带来的开销，yield()方法不应该被经常调用。

等待中(Waiting)：线程由于等待I/O等外部进程的处理结果而处于被阻断的状态，调用currObject.wait( )方法会使得当前线程进入等待状态，直到其它线程调用currObject.notify() 或者currObject.notifyAll() 。

睡眠中(Sleeping)：重载方法Thread.sleep(milliseconds)，Thread.sleep(milliseconds， nanoseconds)可以迫使Java线程进入睡眠状态（挂起）。

由于I/O阻塞（Blocked on I/O）：当I/O条件发生变化时（例如读取了几个字节的数据）会迁移到可执行状态。

由于同步阻塞中（Blocked on synchronization）: 当获取锁之后会进入执行中状态。

Thread.State  枚举类型包含了Java虚拟机支持的全部的线程状态类型，下面几点Java的线程宗旨确保了这些线程状态成为可能。

对象可以被任何线程共享和修改。

线程调度器的抢占性特性，使得线程可以随时在/不在多核处理之间切换处理器内核，这意味着方法可以在执行的过程中切换状态。否则方法中的死循环将永远阻塞CPU，并且使得不同线程的其他方法始终得不到执行。

为了防止线程安全问题，那些脆弱的方法或者代码块可以被锁定。这使得线程可以处于被锁定或者加锁请求处理中两种状态。

线程在处理I/O资源（如Sockets，文件句柄，数据库连接等）时会进入等待状态，

处于I/O读写中的线程不能被切换，因此他们或者以成功/失败的结果正常完成处理，或者其它线程关闭了相应的资源，迫使他进入死亡或者完成的状态。这也是为什么一个合理的超时时间可以避免线程由于I/O处理而被永远阻塞，从而导致严重的性能问题。

线程可以进入睡眠状态，以使得其他处于等待状态的线程有机会执行。

8. yield和sleeping有何区别，sleep()和wait()有何区别？

当一个任务调用了yield()方法，它将从执行中状态转变为可执行。而当一个任务调用了sleep()，则将从执行中状态转变为等待中/睡眠中状态。

方法wait(1000)使得当前线程睡眠1秒钟，但调用notify() 或者notifyAll()会随时唤醒线程。而sleep(1000)则会导致当前线程休眠1秒钟。

Thread.sleep ()使当前线程在指定的时间处于“非运行”（Not Runnable）状态。线程一直持有对象的监视器。比如一个线程当前在一个同步块或同步方法中，其它线程不能进入该块或方法中。如果另一线程调用了 interrupt ()方法，它将唤醒那个“睡眠的”线程。

注意：sleep ()是一个静态方法。这意味着只对当前线程有效，一个常见的错误是调用t.sleep ()，（这里的t是一个不同于当前线程的线程）。即便是执行t.sleep ()，也是当前线程进入睡眠，而不是t线程。t.suspend ()是过时的方法，使用 suspend ()导致线程进入停滞状态，该线程会一直持有对象的监视器，suspend ()容易引起死锁问题。

object.wait ()使当前线程出于“不可运行”状态，和 sleep ()不同的是 wait 是 object 的方法而不是 thread。调用 object.wait ()时，线程先要获取这个对象的对象锁，当前线程必须在锁对象保持同步，把当前线程添加到等待队列中，随后另一线程可以同步同一个对象锁来调用 object.notify ()，这样将唤醒原来等待中的线程，然后释放该锁。基本上 wait ()/notify ()与 sleep ()/interrupt ()类似，只是前者需要获取对象锁。

9. 在一个对象上两个线程可以调用两个不同的同步实例方法吗

　　不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。所以只有执行完该方法释放对象锁后才能执行其它同步方法。看下面代码示例非常清晰：Common 类有 synchronizedMethod1()和 synchronizedMethod2()方法，MyThread 调用这两个方法。

 

10. 以下多线程对int型变量x的操作，哪几个不需要进行同步

 

11. 什么是线程饿死，什么是活锁

死锁定义：一组进程中的每一个进程，均无限期地等待此组进程中某个其他进程占有的，因而永远无法得到的资源，这种现象称为进程死锁。结论：

参与死锁的进程至少有二个

每个参与死锁的进程均等待资源

参与死锁的进程中至少有两个进程占有资源；

死锁进程是系统中当前进程集合的一个子集。

在一个动态系统中，资源请求与释放是经常性发生的进程行为．对于每类系统资源，操作系统需要确定一个分配策略，当多个进程同时申请某类资源时，由分配策略确定资源分配给进程的次序。 资源分配策略可能是公平的(fair)，能保证请求者在有限的时间内获得所需资源；资源分配策略也可能是不公平的(unfair)，即不能保证等待时间上界的存在。 在后一种情况下，即使系统没有发生死锁，某些进程也可能会长时间等待．当等待时间给进程推进和响应带来明显影响时，称发生了进程饥饿(starvation)，当饥饿到一定程度的进程所赋予的任务即使完成也不再具有实际意义时称该进程被饿死(starve to death)。      

 

     考虑一台打印机分配的例子，当有多个进程需要打印文件时，系统按照短文件优先的策略排序，该策略具有平均等待时间短的优点，似乎非常合理，但当短文件打印任务源源不断时，长文件的打印任务将被无限期地推迟，导致饥饿以至饿死。                                                                

 

与饥饿相关的另外一个概念称为活锁 (live lock) ，在忙式等待条件下发生的饥饿，称为活锁。例如不公平的互斥算法

 

不进入等待状态的等待称为忙式等待。另一种等待方式是阻塞式等待，进程得不到共享资源时将进入阻塞状态，让 出 CPU 给其他进程使用。忙等待和阻塞式等待的相同之处在于进程都不具备继续向前推进的条件，不同之处在于处于忙等待的进程不主动放 弃 CPU ， 尽 管 CPU 可 能被剥夺，因而是低效的；而处于阻塞状态的进程主动放弃 CPU ，因而是高效的。

 

有人说活锁是数据资源分配引起的，而饿死是处理器资源分配引起的。不同领域中，本质应该是一样的。

 

我认为活锁的进程不放弃ＣＰＵ的情况下无法完成工作的情况，就如上面网络中说的报文围绕目的节点转悠，却不能真正到达目的节点。而饿死则是放弃ＣＰＵ让其他进程工作，但这一让就成了无限期的让，从而导致了饿死。

12. 什么时候抛出 InvalidMonitorStateException 异常

调用 wait ()/notify ()/notifyAll ()中的任何一个方法时，如果当前线程没有获得该对象的锁，那么就会抛出 IllegalMonitorStateException 的异常(也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用 wait ()/notify ()/notifyAll ()时)。由于该异常是 RuntimeExcpetion 的子类，所以该异常不一定要捕获(尽管你可以捕获只要你愿意).作为 RuntimeException，此类异常不会在 wait (),notify (),notifyAll ()的方法签名提及。

13. Thread.start ()与 Thread.run ()有什么区别，为什么需要 run ()和 start ()方法，我们可以只用 run ()方法来完成任务吗

我们需要 run ()&start ()这两个方法是因为 JVM 创建一个单独的线程不同于普通方法的调用，所以这项工作由线程的 start 方法来完成，start 由本地方法实现，需要显示地被调用，使用这俩个方法的另外一个好处是任何一个对象都可以作为线程运行，只要实现了 Runnable 接口，这就避免因继承了 Thread 类而造成的 Java 的多继承问题。

----------------------------------------------------------------------------------------------------------------------------------------------

run没有启新的线程，start方法才会调用Thread的native的start0方法，start0会调用run方法，开启新的线程，博主这么做，不是多线程顺序执行，而是把业务阻塞在主线程里。请打印：Thread.currentThread().getId()，会发现主线程ID和run里的ID是相同的；如果调用start方法，就不会相同了。

开启新的线程不是run方法做的，是Thread的native方法start0做的，start0在底层请求JVM分配资源，然后start0会调用你重写的Runnable实例的run方法。Runnable是一个接口，这个接口只有一个方法run，Thread类就实现了这个接口。 所以Java里创建线程都必须要实现这个接口，也就是他们都是Runnable实例。只是Runnable实例并不会启动新的线程，必须调用Thread的start方法，才会启动新的线程。可以这么写：new Thread（Runnable）.start()。

----------------------------------------------------------------------------------------------------------------------------------------------

http://www.cnblogs.com/heartstage/p/3416997.html

14. notify和notifyAll的区别

notify()和notifyAll()都是Object对象用于通知处在等待该对象的线程的方法。两者的最大区别在于：

notifyAll使所有原来在该对象上等待被notify的线程统统退出wait的状态，变成等待该对象上的锁，一旦该对象被解锁，他们就会去竞争。 notify则文明得多他只是选择一个wait状态线程进行通知，并使它获得该对象上的锁，但不惊动其他同样在等待被该对象notify的线程们，当第一个线程运行完毕以后释放对象上的锁此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，继续处在wait状态，直到这个对象发出一个notify或notifyAll，它们等待的是被notify或notifyAll，而不是锁。

http://www.cnblogs.com/armyao/archive/2010/12/27/1917989.html