✔ Synchronized Generic ResourcePool

[syz]

Hallo wissende!
habe ein kleines problem mit meinem ResourcePool der mit Semaphore einige probleme des multithreading lösen soll.

import java.util.Stack;
import java.util.concurrent.Semaphore;

public class ResourcePool<T> {
	private int MAX_AVAILABLE;
	private Semaphore semaphore;
	private Stack<T> unused = new Stack<T>();
	private Stack<T> used = new Stack<T>();

	ResourcePool(Stack<T> stack) {
		unused = stack;
		used.clear();
		MAX_AVAILABLE = unused.size();
		semaphore = new Semaphore(MAX_AVAILABLE, false);
	}

	ResourcePool(Stack<T> stack, boolean fair) {
		unused = stack;
		used.clear();
		MAX_AVAILABLE = unused.size();
		semaphore = new Semaphore(MAX_AVAILABLE, fair);
	}

	public T acquire() throws InterruptedException {
		System.out.println(Thread.currentThread().getName()+" trying to get access");
		semaphore.acquire();
		System.out.println(Thread.currentThread().getName()+" access granted");
		return get();
	}

	protected synchronized T get() {
		T temp = unused.pop();
		used.push(temp);
		return temp;
	}

	public void release(T item) {
		System.out.println(Thread.currentThread().getName()+" removing access");
		set(item);
		semaphore.release();
	}
	
	protected synchronized void set(T item) {
		used.remove(item);
		unused.push(item);
	}
	
	public void print() {
		System.out.println("pool inhalt:");
		for (int i=0;i<unused.size();i++) System.out.println(unused.get(i));
	}
}

wie man sieht befindet der sich der Pool noch in der enwicklungsphase
Nun zum problem:

Stack<String> stack = new Stack<String>();
stack.push("test1");
ResourcePool<String> pool = new ResourcePool<String>(stack);
String t = pool.acquire();
t = Thread.currentThread().getName()+" was here!";
pool.release(t);

nachdem releasen der variable "t" kann man trotzdem die resource noch manipulieren.
wie kann man das verhindern?
anregungen und kritik an der klasse ResourcePool sind erwünscht!
Danke!

 

[syz]

hat keiner eine idee?

 

[genodeftest]

Ich wüsste nicht, wie du das technisch realisieren kannst. In deinem Fall besteht das Problem aber nicht: Strings sind immutable, können also nicht geändert werden.

Falls du andere Objekte verwendest, schreib einfach in die JavaDoc, dass man die Elemente nicht verändern darf und hoffe darauf, dass die Nutzer sich daran halten.

Um die ursprünglichen Objekte zu schützen könntest du auch die Objekte nach dem releasen klonen und das geklonte Objekt zurückgeben. Damit wäre das ursprüngliche Objekt sicher vor Manipulation.

 

[syz]

Danke!
Ich glaube nicht das es so funktionieren wird.
Hab was interessantes gefunden: (Dynamische) Proxy:
http://www.gruntz.ch/courses/sem/ws01/DynamischeProxyKlassen.pdf
http://www.dpunkt.de/java/Die_Sprache_Java/Objektorientierte_Programmierung_mit_Java/75.html
Meine das mein Info Dozent davon gesprochen hat, weis es aber nicht genau. Aufjedenfall fiel das wort "Proxy" in verbindung mit dem ResourcePool.
Werde mich mal in die Proxy geschichte reinknien.
Falls jemand mit diesen Proxy's bereits Erfahrung gemacht, bitte gebt euren Senf dazu******

 

[genodeftest]

Danke für die Links, genau das hab ich jetzt grad gebraucht