Замыкания (closure) и многопоточность

Если контекст один, то да, надо синхронизировать. С глобальными переменными аналогия не очень полная, просто контекст это разделяемый между потоками объект.

> Если контекст один

А есть языки, позволяющие множить контекст между потоками?

> А есть языки, позволяющие множить контекст между потоками?

Есть языки в которых можно вызывать замыкание из разных потоков, и не беспокоиться о синхронизации. Например Clojure.

Если свободные переменные нельзя менять, то нет необходимости в синхронизации или создании копий для разных потоков.

Не совсем понятно, что именно нужно, но в коммон лиспе есть динамическое связывание (против обычного лексического). Там контекст множится по потокам, если еще не забыл.

> Не совсем понятно, что именно нужно

Разобраться в вопросе.

Представь, что вызываешь метод одного и того же объекта из двух разных тредов. Вот при вызове замыкания происходит все в точности то же самое.

Тогда можно обратиться к таким языкам как F# или Scala. Когда создается функция (замыкание), то фактически с точки зрения ООП создается новый объект автоматически сгенерированного класса. У этого объекта есть обычно один главный метод. Он называется или Invoke, или Apply. Это и есть вызов функции. У этого объекта есть еще поля. В эти поля и кладутся значения, захваченные замыканием. Эти значения хранятся в этом объекте.

Поэтому если функция одна, а потоков много, то все потоки будут обращаться к одним и тем же значениям полей сгенерированного объекта. Так это выглядит с точки зрения ООП. И это был lexical scope. Такие переменные видны только локально.

Еще есть dynamically scoped переменные в коммон лиспе. Вот, они фактически глобальны, но разделены по потокам.

Но это еще не конец... Почти все переменные могут быть разделены по доменам приложения, но это уже .NET :)

> Как я понял, […], и при повторном вызове функция помнит контекст вызова предыдущего

Ты не правильно понял. Читай про lexical scoping и dinamic scoping. Ничто из них не соответствует твоему «помнит контекст предыдущего вызова».

Кстати, некоторые языки допускают некоторые вольности при захвате замыкания. Переменные могут неявно захватываться по ссылке. В F# это не так. Там можно захватить только значение или явно саму ссылку. Очень помогает пониманию и позволяет не допускать глупых ошибок.

А проблемы с многопоточностью возникают только тогда, когда отходишь от функционального стиля и начинаешь прибегать к побочным эффектам. Иммутабельные же значения (в языках с GC) потокобезопасны.

>> Не совсем понятно, что именно нужно, но в коммон лиспе есть динамическое связывание (против обычного лексического). Там контекст множится по потокам, если еще не забыл.

Динамическое связывание _как_правило_ происходит в каждом потоке отдельно. Но это не описано в стандарте и конкретная реализация не обязана так делать.

Лексическое связывание также может быть, а может и не быть потокобезопасным, все зависит от реализации. В стандарте этого опять же нет.

> Лексическое связывание также может быть, а может и не быть потокобезопасным, все зависит от реализации. В стандарте этого опять же нет.

И как работает потокобезопасное лексическое связывание для замыканий (функций)? Ты себе это представляешь?

>> И как работает потокобезопасное лексическое связывание для замыканий (функций)? Ты себе это представляешь?

Также как потокобезопасное динамическое - копированием связанных переменных (точнее фрейма).

И как это работает, если замыкание создает один поток, а другие только вызывают функцию? Откуда берутся значения в других потоках?

Не понял кто кого вызывает.

Вот и я тебя не понял :)

>то фактически с точки зрения ООП создается новый объект автоматически сгенерированного класса

В C++ также.