java多线程注意事项

Posted 风雨缠舟

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java多线程注意事项相关的知识,希望对你有一定的参考价值。

1:继承thread和实现Runnable创建线程的区别:
 继承thread创建的对象直接start()就可以就绪,但是使用Runnable所new出来的对象要先new Thread(xx)才能start()
 这也就意味着在start()之前实现Runnable的类一次new 出来的对象是可以多次传入new Thread()创建多个线程实例并且多次start()的,就是说
 runnable的数据可以被共享,但是继承thread创建的线程不具备这个功能。

class Thread1 extends Thread{  
    private int count=5;  
    private String name;  
    public Thread1(String name) {  
       this.name=name;  
    }  
    public void run() {  
        for (int i = 0; i < 5; i++) {  
            System.out.println(name + "运行  count= " + count--);  
            try {  
                sleep((int) Math.random() * 10);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
         
    }  
}  
  
public class Main {  
  
    public static void main(String[] args) {  
        Thread1 mTh1=new Thread1("A");  
        Thread1 mTh2=new Thread1("B");  
        mTh1.start();  
        mTh2.start();  
  
    }  
  
}  

2:线程的状态:

           |-阻塞- |
           |      |
    就绪-可运行-运行中-死亡
            |     / |
          |    /  |------等待

 

运行---可运行:thread.yield()
运行--等待:object.wait()
运行--阻塞:thread.sleep() thread.join()
运行--锁:synchronized
等待--锁:object.notify() 或者wait时间到
锁--可运行:

3:解析sleep() wait() yield()的区别:

                sleep                        wait                      yield
所属类:        Thread                     Object                     Thread
目的:            运行到阻塞                    运行到等待                  运行到可运行或者立即重新运行
锁持有状态:    不释放                          释放                        释放
让出cpu资源后:   允许比自己优先级低的运行                                 只允许比自己优先级高或等的执行,也可能自己去执行
使用条件:        任何地方                     必须在同步块或者方法中 

4:常用方法
   sleep(): 强迫一个线程睡眠N毫秒。
  isAlive(): 判断一个线程是否存活。
  join(): 等待线程终止。
  activeCount(): 程序中活跃的线程数。
  enumerate(): 枚举程序中的线程。
    currentThread(): 得到当前线程。
  isDaemon(): 一个线程是否为守护线程。
  setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于,是否等待主线程依赖于主线程结束而结束)
  setName(): 为线程设置一个名称。
  wait(): 强迫一个线程等待。
  notify(): 通知一个线程继续运行。
  setPriority(): 设置一个线程的优先级。

5:synchronized

a:    Public synchronized void methodAAA()//修饰静态方法时锁对象是调用这个方法的对象
    {

    //….

    }
b:public void method3(SomeObject so)//修饰块时锁对象是括号中的对象
    {
        synchronized(so)
        {
       //…..
        }
    }
c: Class Foo{
    public synchronized static void methodAAA()   // 同步的static 函数锁对象是当前类
    {
    }
    public void methodBBB()

    {

           synchronized(Foo.class)   // 等同于上面 

    }

       }

6:经典例子

public class Test {
    public  class myThread implements Runnable{
        private String threadName;
        private Object pre;
        private Object curr;
        public  myThread(String n,Object p,Object c){
            this.threadName=n;
            this.pre=p;
            this.curr=c;
        }
        public void run() {
            // TODO Auto-generated method stub
            int i=10;
            while (i>0){
                synchronized(pre){
                    synchronized(curr){
                        System.out.println(threadName);
                        i--;
                        curr.notify();//通知下一个对象获得锁
                    }
                    try {
                        pre.wait();
                    }catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }//释放对pre对象持有的锁
                }
            }
        }
    }
    public static void main(String[] args){
        Object a=new Object();
        Object b=new Object();
        Object c=new Object();
        Test t=new Test();
        myThread pa=t.new myThread("A",c,a);
        new Thread(pa).start();
        myThread pb=t.new myThread("B",a,b);
        new Thread(pb).start();
        myThread pc=t.new myThread("C",b,c);
        new Thread(pc).start();
    }
}    

 

以上是关于java多线程注意事项的主要内容,如果未能解决你的问题,请参考以下文章

Java多线程与并发库高级应用-工具类介绍

Java多线程与并发库高级应用-工具类介绍

多线程 Thread 线程同步 synchronized

一篇搞懂Java多线程运行机制

python中的多线程和多进程编程

Java多线程具体解释