Эквивалентный из ConcurrentHashMap Java в C#? [дубликат]
Сравните DataFrameGroupBy.cumsum по 1 и цепочку кодирования сравните flag по 1 с bitwise AND и преобразовать в целое число:
df['target1'] = (df.groupby('date')['flag'].cumsum().eq(1) & df['flag'].eq(1)).astype(int)
date time flag target target1
0 2017/4/10 10:00:00 0 0 0
1 2017/4/10 11:00:00 1 1 1
2 2017/4/10 12:00:00 0 0 0
3 2017/4/10 13:00:00 0 0 0
4 2017/4/10 14:00:00 0 0 0
5 2017/4/11 10:00:00 1 1 1
6 2017/4/11 11:00:00 0 0 0
7 2017/4/11 12:00:00 1 0 0
8 2017/4/11 13:00:00 1 0 0
9 2017/4/11 14:00:00 0 0 0
10 2017/4/12 10:00:00 0 0 0
11 2017/4/12 11:00:00 0 0 0
12 2017/4/12 12:00:00 0 0 0
13 2017/4/12 13:00:00 0 0 0
14 2017/4/12 14:00:00 0 0 0
15 2017/4/13 10:00:00 0 0 0
16 2017/4/13 11:00:00 1 1 1
17 2017/4/13 12:00:00 0 0 0
18 2017/4/13 13:00:00 1 0 0
19 2017/4/13 14:00:00 0 0 0
Другое решение: [ 119]
df['target1'] = ((~df.loc[df['flag']==1, 'date'].duplicated())
.reindex(df.index, fill_value=False).astype(int))
3 ответа
C# (Наряду с остальной частью.NET) имеет Хеш-таблицу... Это расположено в Системе. Наборы. Я не уверен, каков "Параллельный" HashMap в Java, но Хеш-таблица должна быть ориентирована на многопотоковое исполнение, когда существует только одно устройство записи и произвольное число читателей... кроме этого, необходимо управлять параллелизмом сами.
Я не знаком с ConcurrentHashMap Вы говорите о. Возможно, Вы могли определить то, что функционирует, это выполняет это, требуется иметь в C# также.
Если Вы просто хотите гарантировать, что набор ориентирован на многопотоковое исполнение для параллельного доступа затем, Вы являетесь лучшими от определения Вашей собственной стратегии блокировки управлять доступом к нему.
Hashtable.Synchronised(...) метод, замеченный в более ранних версиях платформы.NET, был удален (наряду с сокрытием всего ICollection. Реализации SyncRoot через явные реализации в System.Collections.Generic). Это вызвано тем, что каждый раз, когда Вы соединяете публично доступный объект, Вы открываете возможность для других вызывающих сторон соединить Ваши объекты способами, которыми Вы не можете управлять и поэтому заходите в тупик, становятся возможными.
Кроме того, 'синхронизируемый' набор может только гарантировать, что вызовы отдельным участникам безопасны, однако много сценариев включают 'транзакции' включая многих участников. Рассмотрите следующий пример:
if (collection.Contains(item))
collection.Get(item);
map объект (безотносительно типа, который это) мог бы гарантировать этому обоих Contains и Get методы ориентированы на многопотоковое исполнение, но это не может гарантировать, что объект все еще содержится в карте к этому времени Get назван. Вместо этого необходимо использовать код как это:
private readonly object _mapLock = new object();
public void Method()
{
lock (_mapLock)
{
if (collection.Contains(item))
collection.Get(item);
}
}
@Oskar предлагает использовать ReaderWriterLock. Этот класс имеет ужасную реализацию с худшей производительностью, чем простая блокировка. При использовании более новых версий платформы использовать ReaderWriterLockSlim вместо этого.
Основная идея ConcurrentHashMap состоит в том, что он является потокобезопасным БЕЗ необходимости в блокировках. Так что все «идеи использования блокировок» в основном как если бы вы сказали «используйте Java».
Внутри вы используете некоторые операции CAS (сравнение и замена) и гарантируете, что неважно как потоки работают, некоторый инвариант всегда остается верным. Поскольку вы не делаете взаимного исключения (единственная элементарная вещь - это аппаратная операция CAS), вы полностью избегаете возможности возникновения взаимоблокировок и обычно имеет место некоторый прирост производительности. Конечно, реализация структуры данных (намного) сложнее (поэтому круто иметь ее готовой, иначе реализовать ее или даже доказать - головная боль). он действительно работает с большим количеством потоков).
Хотелось бы, чтобы такая вещь была и в .NET framework.