参考自:http://lavasoft.blog.51cto.com/62575/27069/
http://www.360doc.com/relevant/8/9/9/6/276998_more.shtml
关于锁和同步,有一下几个要点:
1. 每个对象只有一个锁;当提到同步时,应该清楚在什么上同步?也就是说,在哪个对象上同步?
2. 不必同步类中所有的方法,类可以同时拥有同步和非同步方法。
3. 如果两个线程要执行一个类中的synchronized方法,并且两个线程
使用相同的实例 来调用方法,那么一次只能有一个线程能够执行方法,另一个需要等待,直到锁被释放。也就是说:如果一个线程在对象上获得一个锁,就没有任何其他线程可以进入(该对象的)类中的任何一个同步方法。
一个实例一个线程
一个实例多个线程
多个实例多个线程
多个线程使用相同的实例 来调用synchronized方法,一次只有一个线程能够执行该方法,其它线程需要等待
多个线程使用不同的实例 来调用synchronized方法,这些线程可同时执行该同步方法
4. 如果线程拥有同步和非同步方法,则非同步方法可以被多个线程自由访问而不受锁的限制。
5. 线程睡眠时,它所持的任何锁都不会释放。线程wait时,释放锁。
6. 线程可以获得多个锁。比如,在一个对象的同步方法里面调用另外一个对象的同步方法,则获取了两个对象的同步锁。
7. 在使用同步代码块时候,应该指定在哪个对象上同步,也就是说要获取哪个对象的锁。
问题总结
1. 问:一个线程在一代码块上锁,需要指定锁住的对象,如果锁的是this,那么别的线程可以再访问该对象的其它同步方法吗?
答:不可以。
例子:
class Mythread implements Runnable {
public void method1() {
Object o = new Object();
/**
* 一个线程得到this的锁,直到该线程执行完该代码块,
* 其它线程才能访问同步方法method2
*/
synchronized (this) {
for (int i = 1; i <= 5; i++) {
for (long j = 0; j < 100000000; j++);
System.out.println(i + ":Thread-1---");
}
}
}
public synchronized void method2() {
for (int i = 1; i <= 5; i++) {
for (long j = 0; j < 100000000; j++);
System.out.println(i + ":Thread-2");
}
}
public void run() {
if (Thread.currentThread().getName().equals("Thread-1")) {
method1();
} else
method2();
}
}
public class MethodAndBlockTest {
public static void main(String[] args) {
Mythread mt = new Mythread();
//Mythread mt2 = new Mythread();如果这行注释打开,new t2s时构造函数中的参数替换为mt2,则输出结果就随机交替输出
Thread t1 = new Thread(mt, "Thread-1");
Thread t2 = new Thread(mt, "Thread-2");
t1.start();
t2.start();
}
}
运行结果:
1:Thread-1---
2:Thread-1---
3:Thread-1---
4:Thread-1---
5:Thread-1---
1:Thread-2
2:Thread-2
3:Thread-2
4:Thread-2
5:Thread-2
2. 问:虚拟锁何时应用?
答:如果一个类有两个同步方法 m1,m2,多个线程调用m1方法时,只有一个线程能运行。就是两个分别调用m1,m2的线程时,也只有一个能运行。
大多说情况下,多个线程调用m1时需要保护一种资源,调用M2时要保护的是另一种资源,如果m1,m2都设成同步方法。两个分别调用这两个方法的线程其实并不产生冲突,但它们都要获取这个实例的锁(同步方法是同步this)而产生了不必要竞争。
这时就要用到虚拟锁。
即将m1和m2方法中各自保护的对象作为参数传进来,然后将同步方法改为同步代码块分别以a1,a2为参数,这样到不同线程调用这两个方法时就不会产生竞争了。
例子:
class SleepTest{
String vLock1 = "vLock1";
String vLock2 = "vLock2";
public void m1(){
synchronized(vLock1){
System.out.println("111");
try {
Thread.sleep(10000);
}
catch (Exception e) {}
//操作f1
}
}
public void m2(){
synchronized(vLock2){
System.out.println("123");
//操作f2
}
}
}
class T1 extends Thread{
SleepTest st;
public T1(SleepTest st){
this.st = st;
}
public void run(){
st.m1();
}
}
class T2 extends Thread{
SleepTest st;
public T2(SleepTest st){
this.st = st;
}
public void run(){
st.m2();
}
}
public class Test {
public static void main(String[] args) throws Exception{
SleepTest st = new SleepTest();
new T1(st).start();
new T2(st).start();
}
}
3. 问:多个线程访问同一个对象的方法,方法中的变量共享否?
答:方法中的局部变量是不共享的
类变量共享
多个线程访问不同对象的方法,都不共享
类变量共享
多个线程访问不同对象的方法,都不共享
例子:
public class ThreadClog {
public static void main(String[] args) {
Consumer c = new Consumer();
Consumer c1 = new Consumer();
Thread t1 = new Thread(c, "Thread-1");
Thread t2 = new Thread(c1, "Thread-2");
t1.start();
t2.start();
}
}
class Consumer implements Runnable {
public void run() {
int count = 0;
while (true) {
//int count=0;
for (int i = 0; i < 11000; i++) {
for (long j = 0; j < 900000000; j++);
count++;
System.out.println(Thread.currentThread().getName() + ": "
+ count);
}
}
}
}
4. 问:一个线程从wait状态被唤醒后,是从改同步方法(或代码块)的起始处执行还是接着wait后面的语句执行?
答:接着wait()后面的语句执行
例子:
public class WaitTest {
public static int flag = 0;
public static void main(String[] args) throws InterruptedException {
ThreadB b = new ThreadB();
Thread t=new Thread(b,"Thread-1");
Thread t1=new Thread(b,"Thread-2");
t.start();
t1.start();
}
}
class ThreadB implements Runnable {
private boolean flag = true;
public void run() {
if (Thread.currentThread().getName().equals("Thread-1")) {
try {
method1();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
method2();
}
}
public synchronized void method1() throws InterruptedException {
System.out.println("--start!");
Thread.sleep(2000);
if (flag) {
wait();
}
System.out.println("-----sysn1 end!");
}
public synchronized void method2() {
synchronized (this) {
System.out.println("sysn2 等待....");
notify();
flag = false;
System.out.println("-----sysn2 end!");
}
}
}
运行结果:
--start!
sysn2 等待....
-----sysn2 end!
-----sysn1 end!
5. 问:join方法有什么作用?
答:确保调用join方法的线程执行完毕再执行其它线程
也可以使用参数规定该线程可以保持运行的时间,过期无效
例子:
class OtherThread extends Thread{
public OtherThread(String name){
super(name);
}
public void run(){
for(int i=0;i<5;i++){
for(long j=0;j<10000000;j++);
System.out.println(this.getName()+": "+i);
}
}
}
public class SimpleThread extends Thread {
public SimpleThread(String name){
super(name);
}
public void run(){
for(int i=0;i<5;i++){
for(long j=0;j<10000000;j++);
System.out.println(this.getName()+": "+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1=new SimpleThread("张三");
Thread t2=new OtherThread("李四");
t1.start();
t1.join();
t2.start();
t2.join();
System.out.println("main over!");
}
}
输出结果:
张三: 0
张三: 1
张三: 2
张三: 3
张三: 4
李四: 0
李四: 1
李四: 2
李四: 3
李四: 4
main over!
6.问:守护线程和用户线程的区别?
答:用户线程:Java虚拟机在它所有非守护线程已经离开后自动离开。
守护线程:守护线程则是用来服务用户线程的,如果没有其他用户线程在运行,那么就没有可服务对象,也就没有理由继续下去。
setDaemon(boolean on)方法必须在线程启动之前调用
Java垃圾回收线程就是一个典型的守护线程
守护线程:守护线程则是用来服务用户线程的,如果没有其他用户线程在运行,那么就没有可服务对象,也就没有理由继续下去。
setDaemon(boolean on)方法必须在线程启动之前调用
Java垃圾回收线程就是一个典型的守护线程
例子:
public class DaemonTest extends Thread {
public DaemonTest(String name){
super(name);
}
public void run(){
for(int i=1;i<=100;i++){
try{
Thread.sleep(100);
}catch(InterruptedException ex){
}
System.out.println(i);
}
}
public static void main(String[] args) throws IOException {
DaemonTest test=new DaemonTest("Daemon");
test.setDaemon(true);
test.start();
System.out.println("Daemon is Daemon:"+test.isDaemon());
Thread.sleep(300);
}
}
运行结果:
Daemon is Daemon:true
1
2
3
7.问:Java创建线程的方法,以及给不同的创建方式创建的线程起名
8.问:线程与线程对象,线程与运行环境
9.问:线程的中断和中断线程
10.问:线程池