Java-Parallelprogrammierung (4) Leistung und Skalierbarkeit

Leistung und Skalierbarkeit

1. Die Beziehung zwischen Problemen und Ressourcen

Bei manchen Problemen gilt: Je mehr Ressourcen, desto schneller Fragen sind das Gegenteil:

Hinweis: Jedes Programm muss einen seriellen Teil haben, und die Auswirkungen der seriellen und parallelen Teile auf das Programm sollten dort angemessen analysiert werden ist eine exponentielle Beziehung zwischen dem Anteil des seriellen Teils und der Multi-Core-Ausführungseffizienz

2.ConcurrentLinkedQueue

In einer Multi-Core-Umgebung ist diese threadsichere Warteschlange effizienter als die Warteschlange generiert durch synchronisiertList Die Geschwindigkeit ist viel schneller

Man kann sagen, dass die gleichzeitig bereitgestellten Klassen schneller sind als die durch Methoden generierten Thread-sicheren Klassen

2. Thread-Overhead

Da Multithreading einen Overhead hat: Daher muss die Verwendung von Multithreading eine Leistungsverbesserung gewährleisten>Parallelitäts-Overhead

; Kontextwechsel-Overhead

3 . Reduzieren Sie die Sperrkonkurrenz

　1. Reduzieren Sie die Sperrhaltezeit: Reduzieren Sie den Umfang der Sperre

private final Map<String, String> attributes = new HashMap<String, String>();//整个方法上锁public synchronized boolean userLocationMatches(String name, String regexp) {
        String key = "users." + name + ".location";
        String location = attributes.get(key);if (location == null)return false;elsereturn Pattern.matches(regexp, location);
    }public boolean userLocationMatches(String name, String regexp) {
        String key = "users." + name + ".location";
        String location;//只针对可变状态上锁synchronized (this) {
            location = attributes.get(key);
        }if (location == null)return false;elsereturn Pattern.matches(regexp, location);
    }

　2. Reduzieren Sie die Häufigkeit Anzahl der Sperranforderungen: Sperrenzerlegung, Sperrenteilung Abschnitt ...

Sperrenzerlegung: Zerlegen Sie eine Sperre in mehrere Sperren. Beispiel: Es ist nicht erforderlich, mehrere Statusvariablen in einer atomaren Operation zu aktualisieren, sondern jede Statusvariable verwendet die gleiche Klassensperre. Verwenden Sie bei Bedarf einfach eine eigene Sperre für jede irrelevante Zustandsvariable

public class ServerStatusBeforeSplit {public final Set<String> users;public final Set<String> queries;public ServerStatusBeforeSplit() {
        users = new HashSet<String>();
        queries = new HashSet<String>();
    }//每个方法使用 当前class实例锁，类似于synchronized(this),不管是否是操作同一共享状态public synchronized void addUser(String u) {
        users.add(u);
    }public synchronized void addQuery(String q) {
        queries.add(q);
    }public synchronized void removeUser(String u) {
        users.remove(u);
    }public synchronized void removeQuery(String q) {
        queries.remove(q);
    }
}public class ServerStatusAfterSplit {public final Set<String> users;public final Set<String> queries;//操作同一 状态的方法 使用相同的锁public ServerStatusAfterSplit() {
        users = new HashSet<String>();
        queries = new HashSet<String>();
    }public void addUser(String u) {synchronized (users) {
            users.add(u);
        }
    }public void addQuery(String q) {synchronized (queries) {
            queries.add(q);
        }
    }public void removeUser(String u) {synchronized (users) {
            users.remove(u);
        }
    }public void removeQuery(String q) {synchronized (users) {
            queries.remove(q);
        }
    }
}

　

Sperrsegmentierung: so als Map-Bucket Teilen Sie es in verschiedene Segmente auf, und jedes Segment verfügt über eine Sperre. Auf diese Weise können Sie beim Ausführen bestimmter Vorgänge, z. B. get, unterschiedliche Sperren beibehalten, um die Parallelitätseffizienz zu verbessern. Natürlich müssen einige Vorgänge die Sperren aller beibehalten Segmente des Behälters gleichzeitig, wie z. B. durchsichtig usw.

//Map分段锁实现public class StripedMap {// Synchronization policy: buckets[n] guarded by locks[n%N_LOCKS]private static final int N_LOCKS = 16;  //锁数量private final Node[] buckets;           //容器桶private final Object[] locks;           //同步监听器对象数组private static class Node {
        Node next;
        Object key;
        Object value;
    }public StripedMap(int numBuckets) {
        buckets = new Node[numBuckets];
        locks = new Object[N_LOCKS];for (int i = 0; i < N_LOCKS; i++)
            locks[i] = new Object();
    }private final int hash(Object key) {return Math.abs(key.hashCode() % buckets.length);
    }public Object get(Object key) {int hash = hash(key);//获取当前 key对应的index区域的锁，只获取了一个锁synchronized (locks[hash % N_LOCKS]) {for (Node m = buckets[hash]; m != null; m = m.next)if (m.key.equals(key))return m.value;
        }return null;
    }public void clear() {for (int i = 0; i < buckets.length; i++) {//获取 每个i对应的锁，就是获取了整个容器所有的分段锁synchronized (locks[i % N_LOCKS]) {
                buckets[i] = null;
            }
        }
    }
}

　3. Vermeiden Sie Hotspot-Bereiche

　Der Wettbewerb um Sperren von Hotspot-Ressourcen ist hart, was zu Leistungsproblemen führt

4. Ersetzen Sie exklusive Sperren

Beispiel: Lese-/Schreibsperre: Lesen und Lesen können parallelisiert werden, um dies zu verhindern ausschließliche Verwendung; atomare Zustandsmengen verwenden; unveränderliche Objekte verwenden usw.

5. Kontextwechsel reduzieren

Der Aufgabenwechsel zwischen blockierenden und nicht blockierenden Zuständen ähnelt einem Kontextwechsel

Zum Beispiel: Protokoll-, Protokolldruck- und E/A-Vorgänge führen zu einer großen Anzahl von Blockierungen und Freigaben, was zu Leistungsproblemen führt

Das obige ist der detaillierte Inhalt vonJava-Parallelprogrammierung (4) Leistung und Skalierbarkeit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!