线程有几种表示办法，都是什么？同步有几种实现办法，都是什么？

Question

线程有几种表示办法?楼主是什么意思,是说怎么extends Thread类,implements Runnable接口?重写void run()方法同步:通过synchronized即可,可以给对象/方法加锁

Answer 1

synchronized(object),object相当于一把钥匙（可以是任意的对象类型），每个对象都有一个唯一的钥匙。

Answer 2

看例程：package ProducerConsumer;
class Consumer extends Thread
{
CircularBuffer cbc=null;


 Consumer(CircularBuffer cb)
{cbc=cb;}
public void run(){
for(int i=0;i<=50000;i++)
try{
cbc.get();
}
catch (Exception err){

}

}

}package ProducerConsumer;
import java.io.*;
class CircularBuffer
{
int bufsize;
int[] store;
int numOfEntries=0;
int front=0;
int back=0;

CircularBuffer(int n)
{
bufsize=n;
store=new int[bufsize];

}
synchronized void put(int obj)throws Exception{
if(numOfEntries==bufsize)
{
System.out.println("Producer waiting");

wait();

}
store[back]=obj;
back++;
if(back==bufsize)  back=0;
else {numOfEntries++;
System.out.println("putting   "+   obj);

notify();
}

}

synchronized int get() throws Exception{
int result=0;
if(numOfEntries==0)
{
System.out.println("Consumer waiting");
wait();
}

else{
result=store[front];
front++;
if(front==bufsize) front=0;



numOfEntries--;
System.out.println("getting   "+result);//;
notify();
}
return result;



}

public static void main(String[] args)
{
}
}package ProducerConsumer;
import java.io.*;
class ProCum{
public static void main(String[] args){

CircularBuffer cb=new CircularBuffer(20);


Producer pro=new Producer(cb);
Consumer con=new Consumer(cb);
//
Thread a=null;
Thread b=null;

a=new Thread(pro);

b=new Thread(con);
b.start();
a.start();

}
}

Answer 3

我对synchronized的理解(刚得到的体会)synchronized(obj)
{some_code;}的语义是：
当某个线程将要执行some_code时，他先看看obj有没有被别的线程锁住，如果没有被锁住，该线程就把obj对象的状态变成锁住状态，然后执行some_code中的代码,但是当执行过程中，别的线程中要执行类似synchronized(obj){another_code;} 的语句时该线程会挂起，直到some_code被执行完，并且obj的状态改变为释放状态时，another_code才会被执行。
obj象厕所的门，一个人进去后会把门关上，用完出来后，门就会打开的了，而且一次只能一人用:)
注意obj用随便什么对象都可以，但是要实现代码段的同步，必须是同一个对象。例子：
//========================================
//文件名:TestSync.java
//2004-09-09//主线程类Main
public class TestSync
{
  public static void main(String[] args)
  {
    //用来充当同步锁的某对象
    Object sync = new Object();
    //某共享数据
    ShareDat dat = new ShareDat("初始值");
    System.out.println("主线程 " + dat.getId());    new TestThread(dat,sync,1).start();
    new TestThread(dat,sync,2).start();
    new TestThread(dat,sync,3).start();
  }
}//使用共享数据的线程
class TestThread extends Thread
{
  private ShareDat dat = null;
  private Object sync = null;
  private int number;  public TestThread(ShareDat dat,Object sync,int number)
  {
    super();
    this.dat = dat;
    this.sync = sync;
    this.number = number;
  }  public void run()
  {
    while(true)
    {
      //如果不用synchronized,打印的线程号
      //可能会和共享数据中存储的线程号不一致
  synchronized(sync){
        dat.setId(number+"号线程改变了ShareDat的值\t");        System.out.println(
number + "号线程的第一行信息\t"+dat.getId()+"*");        BigCalc.calc();        System.out.println(
number+"号线程的第二行信息\t"+dat.getId()+"**");
      }
  
      try
      {
        sleep(1000);
      }
      catch(InterruptedException ex)
      {
        ex.printStackTrace();
      }
      BigCalc.calc();
    }
  }
}//共享数据对象
class ShareDat
{
  private String id;  public ShareDat(String id){this.id = id;}
  public String getId(){return this.id;}
  public void setId(String id){this.id = id;}
}//产生随机的延时的对象
class BigCalc
{
  public static void calc()
  {
    int cnt = (int)(1 + 99 * Math.random());
    double[] opr = new double[cnt];
    try
    {
      for(int i=0;i<cnt;i++)
      {
        opr[i] = 1/Math.sqrt(Math.random());
      }
      for(int k=0;k<10000;k++)
      {
        for(int i=0;i<=cnt-2;i++)
        {
          double x = Math.pow(opr[i],3*Math.abs(Math.sin(opr[i])));
          double y = Math.pow(opr[i+1],3*Math.abs(Math.sin(opr[i+1])));
          opr[i] = Math.sqrt(x*x+y*y);
        }
  }
    }
    catch(Exception ex){}
  }
}
//====================================但是如果把：
  public static void main(String[] args)
  {
    //用来充当同步锁的某对象
    Object sync = new Object();
    //某共享数据
    ShareDat dat = new ShareDat("初始值");
    System.out.println("主线程 " + dat.getId());    new TestThread(dat,sync,1).start();
    new TestThread(dat,sync,2).start();
    new TestThread(dat,sync,3).start();
  }
}
写成：
  public static void main(String[] args)
  {
    //用来充当同步锁的某对象
    //Object sync = new Object();
    //某共享数据
    ShareDat dat = new ShareDat("初始值");
    System.out.println("主线程 " + dat.getId());    //new TestThread(dat,sync,1).start();
    //new TestThread(dat,sync,2).start();
    //new TestThread(dat,sync,3).start();
    new TestThread(dat,new Object(),1).start();
    new TestThread(dat,new Object(),2).start();
    new TestThread(dat,new Object(),3).start();
  }
}
就起不到同步的作用了。

Answer 4

有两种实现方法，　一种是通过继承类，　一种是通过继承接口，
synchronize来同步