在Java中，它'；每个线程有可能是单线程吗？

使用线程，我有一个主体类（

SlaveCrawler

），它实例化了三个相互依赖的类（

Downloader、ContentAnalyzer、urlayzer

）

SlaveCrawler

使用

Downloader

和

urlayzer

Downloader

使用

ContentAnalyzer

和

urlayzer

ContentAnalyzer

使用

urlayzer

我只想要每个类的一个实例。如果我使用

Singleton

，我可以得到这个，但是使用线程，我将有20个

SlaveCrawlers

（示例），所以我想要20个

urlayzer

可以使用

Singleton

来实现这一点，或者我需要另一种方式？

看看。每个线程都有自己的每个对象的本地副本

ThreadLocal<YourObject> threadLocalYourObject = new ThreadLocal<YourObject>() {
  @Override
  protected YourObject initialValue() {
    //initialize YourObject
  }
}

对。这是可能的

在方法“whichreturnthesingleton”（例如getInstance（））中，使用线程本地存储检查（并在需要时创建）要返回的singleton对象的实例

然而，这听起来相当混乱。考虑不使用“单点模式”；而是根据需要传递相同的对象（或者考虑使用DI框架）。

---

愉快的编码。

您可以使用ThreadLocal实现它。 以下是伪代码：

public class ThreadLocalTest {

  public static void main(String[] args){
    MyTLSingleTon obj = MyTLSingleTon.getInstance();
  }

}

class MyTLSingleTon{

  private MyTLSingleTon(){  
  }

  private static final ThreadLocal<MyTLSingleTon> _localStorage = new ThreadLocal<MyTLSingleTon>(){
    protected MyTLSingleTon initialValue() {
      return new MyTLSingleTon();
   }
  };

  public static MyTLSingleTon getInstance(){
    return _localStorage.get();
  }
}

public类ThreadLocalTest{
公共静态void main（字符串[]args）{
MyTLSingleTon obj=MyTLSingleTon.getInstance（）；
}
}
类MyTLSingleTon{
私有MyTLSingleTon（）{
}
私有静态最终ThreadLocal_localStorage=new ThreadLocal（）{
受保护的MyTLSingleTon初始值（）{
返回新的MyTLSingleTon（）；
}
};
公共静态MyTLSingleTon getInstance（）{
返回_localStorage.get（）；
}
}

MyTLSingleTon.getInstance（）

方法并设置一个新实例。

我使用了上述实现，我能够实现每个线程的单个对象。
I have used the implementation as explained above, I am able to achieve the single object per thread.
Below is my complete implementation

package example.test;

public class ThreadLevelSingleton
{
    public static void main(String[] args)
    {
        Thread33 t3 = new Thread33();
        t3.run();

        Thread44 t4 = new Thread44();
        t4.run();

        MySingleTon m1 = MySingleTon.getInstance();
        MySingleTon m2 = MySingleTon.getInstance();

        System.out.println(Thread.currentThread().getName() + " : " + (m1 == m2));

        MySingleTon tm1 = t3.getMySingleTon();
        MySingleTon tm2 = t4.getMySingleTon();
        System.out.println(Thread.currentThread().getName() + " : " + (tm1.equals(tm2)));
    }
}

class MySingleTon
{
    private MySingleTon()
    {
    }

    private static final ThreadLocal<MySingleTon> t = new ThreadLocal<MySingleTon>()
    {
        @Override
        protected MySingleTon initialValue()
        {
            return new MySingleTon();
        }
    };

    public static MySingleTon getInstance()
    {
        return t.get();
    }
}

class Thread33 extends Thread
{
    MySingleTon m1;

    @Override
    public void run()
    {
        MySingleTon t = MySingleTon.getInstance();
        MySingleTon t1 = MySingleTon.getInstance();
        m1 = MySingleTon.getInstance();
        System.out.println(getName() + " : " + (t == t1));
        System.out.println(t);
        System.out.println(t1);
    }

    MySingleTon getMySingleTon()
    {
        return m1;
    }
}

class Thread44 extends Thread
{
    MySingleTon m1;

    @Override
    public void run()
    {
        MySingleTon t = MySingleTon.getInstance();
        MySingleTon t1 = MySingleTon.getInstance();
        m1 = MySingleTon.getInstance();
        System.out.println(getName() + " : " + (t == t1));
        System.out.println(t);
        System.out.println(t1);
    }

    MySingleTon getMySingleTon()
    {
        return m1;
    }
}

下面是我的完整实现
包装试验；
公共类ThreadLevelSingleton
{
公共静态void main（字符串[]args）
{
螺纹33 t3=新螺纹33（）；
t3.run（）；
螺纹44 t4=新螺纹44（）；
t4.run（）；
MySingleTon m1=MySingleTon.getInstance（）；
MySingleTon m2=MySingleTon.getInstance（）；
System.out.println（Thread.currentThread（）.getName（）+“：”+（m1==m2））；
MySingleTon tm1=t3.getMySingleTon（）；
MySingleTon tm2=t4.getMySingleTon（）；
System.out.println（Thread.currentThread（）.getName（）+“：”+（tm1.equals（tm2））；
}
}
迈辛格尔顿班
{
二等兵迈辛格尔顿（）
{
}
私有静态final ThreadLocal t=new ThreadLocal（）
{
@凌驾
受保护的MySingleTon初始值（）
{
返回新的MySingleTon（）；
}
};
公共静态MySingleTon getInstance（）
{
返回t.get（）；
}
}
类Thread33扩展线程
{
迈辛格尔顿m1；
@凌驾
公开募捐
{
MySingleTon t=MySingleTon.getInstance（）；
MySingleTon t1=MySingleTon.getInstance（）；
m1=MySingleTon.getInstance（）；
System.out.println（getName（）+“：”+（t==t1））；
系统输出打印ln（t）；
系统输出打印项次（t1）；
}
MySingleTon getMySingleTon（）
{
返回m1；
}
}
类Thread44扩展线程
{
迈辛格尔顿m1；
@凌驾
公开募捐
{
MySingleTon t=MySingleTon.getInstance（）；
MySingleTon t1=MySingleTon.getInstance（）；
m1=MySingleTon.getInstance（）；
System.out.println（getName（）+“：”+（t==t1））；
系统输出打印ln（t）；
系统输出打印项次（t1）；
}
MySingleTon getMySingleTon（）
{
返回m1；
}
}

为什么不在启动时传递引用？您没有“循环”，那么问题出在哪里？@akappa:IMO使用线程本地作为泛型（非任务特定），但线程不安全资源是一个很好的选择。例如，如果你有100个任务，但有10个工作线程，那么你只能实例化10个这样的资源，而不是用这种方式实例化100个。是的，我也可以这样做，但我在方法中避免了太多的参数。我觉得比较干净，维修比较方便。目前我对此没有任何问题，但我认为每个对象一个实例更好，但如果没有办法，我将使用引用。现在我将测试这些答案，看看有什么更好。你不必明确地保留

YourObject

的副本。另外，您不需要实现get（）方法（实际上，此解决方案将始终为所有线程返回相同的副本）

public class ThreadLocalTest {

  public static void main(String[] args){
    MyTLSingleTon obj = MyTLSingleTon.getInstance();
  }

}

class MyTLSingleTon{

  private MyTLSingleTon(){  
  }

  private static final ThreadLocal<MyTLSingleTon> _localStorage = new ThreadLocal<MyTLSingleTon>(){
    protected MyTLSingleTon initialValue() {
      return new MyTLSingleTon();
   }
  };

  public static MyTLSingleTon getInstance(){
    return _localStorage.get();
  }
}

I have used the implementation as explained above, I am able to achieve the single object per thread.
Below is my complete implementation

package example.test;

public class ThreadLevelSingleton
{
    public static void main(String[] args)
    {
        Thread33 t3 = new Thread33();
        t3.run();

        Thread44 t4 = new Thread44();
        t4.run();

        MySingleTon m1 = MySingleTon.getInstance();
        MySingleTon m2 = MySingleTon.getInstance();

        System.out.println(Thread.currentThread().getName() + " : " + (m1 == m2));

        MySingleTon tm1 = t3.getMySingleTon();
        MySingleTon tm2 = t4.getMySingleTon();
        System.out.println(Thread.currentThread().getName() + " : " + (tm1.equals(tm2)));
    }
}

class MySingleTon
{
    private MySingleTon()
    {
    }

    private static final ThreadLocal<MySingleTon> t = new ThreadLocal<MySingleTon>()
    {
        @Override
        protected MySingleTon initialValue()
        {
            return new MySingleTon();
        }
    };

    public static MySingleTon getInstance()
    {
        return t.get();
    }
}

class Thread33 extends Thread
{
    MySingleTon m1;

    @Override
    public void run()
    {
        MySingleTon t = MySingleTon.getInstance();
        MySingleTon t1 = MySingleTon.getInstance();
        m1 = MySingleTon.getInstance();
        System.out.println(getName() + " : " + (t == t1));
        System.out.println(t);
        System.out.println(t1);
    }

    MySingleTon getMySingleTon()
    {
        return m1;
    }
}

class Thread44 extends Thread
{
    MySingleTon m1;

    @Override
    public void run()
    {
        MySingleTon t = MySingleTon.getInstance();
        MySingleTon t1 = MySingleTon.getInstance();
        m1 = MySingleTon.getInstance();
        System.out.println(getName() + " : " + (t == t1));
        System.out.println(t);
        System.out.println(t1);
    }

    MySingleTon getMySingleTon()
    {
        return m1;
    }
}