java - 柔軟な一時ゲーム データ ストレージ システムの作成

Question

私は Java で 2D 物理ゲームを作成していますが、最近、プログラムの基盤が柔軟性とスレッド化を念頭に置いているため、完全にやり直すことにしました。私の問題は、スレッド化を念頭に置いて、プログラムの実行中にゲーム データを保存する方法を見つけることです。

データを保存するための以前のライブラリは次のようになりました

public float[] sphereX = new float[sphereNum];
public float[] sphereY = new float[sphereNum];
public float[] sphereXMem = new float[sphereNum];
public float[] sphereYMem = new float[sphereNum];
public float[] sphereVX = new float[sphereNum]; // X Velocity
public float[] sphereVY = new float[sphereNum]; // Y Velocity

// Misc Variables
public float[] sphereMass = new float[sphereNum];
public float[] sphereRadius = new float[sphereNum];

これは、スレッドがなく機能が少ないプログラムには適していましたが、現在のプログラムには、この以前のバージョンでは対処できなかったいくつかの新しい要件があります。これらには以下が含まれます：

• 球の量は常に変化しています
• 球にはさらに多くのデータ型があります。(boolean、int、および float)
• このゲーム データは、複数のスレッドによって継続的にアクセスおよび変更されています

ロック キーが使用可能になるまでスレッドをデータからロックアウトすると、プログラムの速度が大幅に低下するのではないかと心配しています。

私の現在の解決策のアイデアは、そのオブジェクトのパラメーターの配列を含むオブジェクトの Arraylist を持つことですが、それをスレッドで機能させる方法についての手がかりがありません。

お察しのとおり、私はスレッド化に関しては初心者ですが、揮発性と基本的な同期の基本的な概念は知っています。また、知りたい場合は、スレッドを使用して、プログラムが複数のコアを利用できるようにすることを願っています。

編集：コメントを検討した後、私はこれを思いつきました。これは正しいですか？最初は別のクラスを作成するつもりはありませんでしたが、おそらく最善の方法です。こんなことを聞​​くのはばかげていますが、すべてを別のファイルに配置した場合、その情報は保持されますか? これから、メイン クラスの ArrayList に複数のアイテム (アイテムは新しい球体) を追加するだけですか?

enter code here`public class Item 
{
    private Object lockActive = new Object();
    private Object lockType = new Object();
    private Object lockMass = new Object();
    private Object lockLocation = new Object();
    private Object lockLocationMemory = new Object();
    private Object lockVelocity = new Object();

    private boolean active;
    private int type;
    private float mass;
    private float[] location;
    private float[] locationMemory;
    private float[] velocity;

    public Item(boolean active, int type, float mass, float[] location, float[] locationMemory, float[] velocity) 
    {
        this.active = active;
        this.type = type;
        this.mass = mass;
        this.location = location;
        this.locationMemory = locationMemory;
        this.velocity = velocity;
    }

    public boolean GetActive() 
    {
        synchronized (lockActive)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            return active;
        }
    }

    public synchronized int GetType() 
    {
        synchronized (lockType)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            return type;
        }
    }

    public synchronized float GetMass() 
    {
        synchronized (lockMass)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            return mass;
        }
    }

    public synchronized float[] GetLocation() 
    {
        synchronized (lockLocation)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            return location;
        }
    }

    public synchronized float[] GetLocationMemory() 
    {
        synchronized (lockLocationMemory)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            return locationMemory;
        }
    }

    public synchronized float[] GetVelocity() 
    {
        synchronized (lockVelocity)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            return velocity;
        }
    }

    public void SetActive() 
    {
        synchronized (lockActive)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            this.active = active;
        }
    }

    public void SetType(int type) 
    {
        synchronized (lockType)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            this.type = type;
        }
    }

    public void SetMass(float mass) 
    {
        synchronized (lockMass)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            this.mass = mass;
        }
    }

    public void SetLocation(float[] location) 
    {
        synchronized (lockLocation)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            this.location = location;
        }
    }

    public void SetLocationMemory(float[] locationMemory) 
    {
        synchronized (lockLocationMemory)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            this.locationMemory = locationMemory;
        }
    }

    public void SetVelocity(float[] velocity) 
    {
        synchronized (lockVelocity)
        {
            try
            {
                Thread.sleep(1);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            this.velocity = velocity;
        }
    }

}